*/
		public void paintComponent(Graphics g) {
			
			super.paintComponent(g);
			
			final FontUIResource font1 = new FontUIResource(
					g.getFont().getFamily(),g.getFont().getStyle(),14);	// フォント1
			final FontUIResource font2 = new FontUIResource(
					g.getFont().getFamily(),g.getFont().getStyle(),9);	// フォント2
			final FontUIResource font3 = new FontUIResource(
					g.getFont().getFamily(),g.getFont().getStyle(),12);	// フォント3
			
			// 画面サイズ再設定
			width = getWidth();
			height = getHeight();
			
			// グラフの可動に関する設定の再設定（画面リサイズに対応するための処理）
			setAngleProperty();
			
			// 描画エリア全体の背景描画
			g.setColor(Color.WHITE);
			g.fillRect(0, 0, width, height);
			
			// x軸方向拡大率の算出
//			xscale = (width - 2.0f * MARGIN) / massRange;
			xscale = (width - (2.0d * MARGIN) - ((recNum-1) * moveXPoint)) / massRange;
			if (xscale < 0d) {
				xscale = 0d;
			}
			
			// y軸方向拡大率の算出
//			float yscale = (height - (float)(MARGIN +marginTop) ) / intensityRange;
			yscale = (height - (double)(MARGIN + marginTop + (recNum-1) * moveYPoint) ) / intensityRange;
			if (yscale < 0d) {
				yscale = 0d;
			}
			
			int tmpMarginTop = 0;
			int tmpMarginRight = 0;
			
			int baseX = 0;			// x軸とy軸の交点のx座標
			int baseY = 0;			// x軸とy軸の交点のy座標
			int nextBaseX = 0;		// 次レコードのx軸とy軸の交点のx座標
			int nextBaseY = 0;		// 次レコードのx軸とy軸の交点のy座標
			
			int loopCount = ((recNum != 0) ? recNum : (recNum + 1));
			
			// グラフ背景色を描画
			int[] sideXPlots = new int[4];		// グラフ側面用x軸
			int[] sideYPlots = new int[4];		// グラフ側面用y軸
			int[] backXPlots = new int[4];		// グラフ背面用x軸
			int[] backYPlots = new int[4];		// グラフ背面用y軸
			int[] bottomXPlots = new int[4];	// グラフ底面用x軸
			int[] bottomYPlots = new int[4];	// グラフ底面用y軸
			for (int i=0; i<loopCount; i++) {
				
				baseX = MARGIN + (loopCount-1-i) * moveXPoint;
				baseY = height - MARGIN - (loopCount-1-i) * moveYPoint;

				nextBaseX = baseX - moveXPoint;
				nextBaseY = baseY + moveYPoint;
				
				tmpMarginTop = marginTop + (i * moveYPoint);
				tmpMarginRight = marginRight + (i * moveXPoint);
				if (tmpMarginTop > baseY) {
					tmpMarginTop = baseY;
				}
				if (width - tmpMarginRight < baseX) {
					tmpMarginRight = (width - baseX > 0) ? (width - baseX) : 0;
				}
				
				if ( i == 0 ) {
					sideXPlots[0] = baseX;
					sideYPlots[0] = tmpMarginTop;
					sideXPlots[1] = baseX;
					sideYPlots[1] = baseY;
					
					backXPlots[0] = baseX;
					backYPlots[0] = tmpMarginTop;
					backXPlots[1] = width - tmpMarginRight;
					backYPlots[1] = tmpMarginTop;
					backXPlots[2] = width - tmpMarginRight;
					backYPlots[2] = baseY;
					backXPlots[3] = baseX;
					backYPlots[3] = baseY;
					
					bottomXPlots[0] = baseX;
					bottomYPlots[0] = baseY;
					bottomXPlots[1] = ((width - tmpMarginRight > baseX) ? (width - tmpMarginRight) : baseX);
					bottomYPlots[1] = baseY;
				}
				if ( i == (loopCount-1) ) {
					sideXPlots[2] = baseX;
					sideYPlots[2] = baseY;
					sideXPlots[3] = baseX;
					sideYPlots[3] = tmpMarginTop;
					
					bottomXPlots[2] = width - tmpMarginRight;
					bottomYPlots[2] = baseY;
					bottomXPlots[3] = baseX;
					bottomYPlots[3] = baseY;
				}
			}
			g.setColor(graphColorBack);
			g.fillPolygon(backXPlots, backYPlots, 4);		// 背面
			
			g.setColor(graphColorSide);
			g.fillPolygon(sideXPlots, sideYPlots, 4);		// 側面
			
			g.setColor(graphColorBottom);
			g.fillPolygon(bottomXPlots, bottomYPlots, 4);	// 底面
			
			
			
			// グラフグリッド描画
			g.setFont(font2);
			for (int i=0; i<loopCount; i++) {
 				g.setColor(Color.LIGHT_GRAY);
				
				baseX = MARGIN + (loopCount-1-i) * moveXPoint;
				baseY = height - MARGIN - (loopCount-1-i) * moveYPoint;
				
				nextBaseX = baseX - moveXPoint;
				nextBaseY = baseY + moveYPoint;
				
				tmpMarginTop = marginTop + (i * moveYPoint);
				tmpMarginRight = marginRight + (i * moveXPoint);
				if (tmpMarginTop > baseY) {
					tmpMarginTop = baseY;
				}
				if (width - tmpMarginRight < baseX) {
					tmpMarginRight = (width - baseX > 0) ? (width - baseX) : 0;
				}
				
				int step = stepCalc((int)massRange);
				int start = (step - (int)massStart % step) % step;
				
				// x軸
				for (int j=start; j<(int)massRange; j+=step) {
					g.setColor(gridColor2);
					// x軸を基準にグラフ背面y軸グリッド描画
					if ( i == 0 ) {
						g.drawLine(baseX + (int)(j * xscale),
								   baseY,
								   baseX + (int)(j * xscale),
								   tmpMarginTop);
					}
					
					// x軸を基準にグラフ底面z軸グリッド描画
					if ( i != (loopCount-1) ) {
						g.drawLine(baseX + (int)(j * xscale),
								   baseY,
								   nextBaseX + (int)(j * xscale),
								   nextBaseY);
					}
					
					g.setColor(gridColor1);
					// グラフ基準x軸目盛り描画
					g.drawLine(baseX + (int)(j * xscale),
							   baseY,
							   baseX + (int)(j * xscale),
							   baseY + 2);
					
					// グラフ基準x軸へのm/z文字列描画
					if (i == (loopCount-1)) {
						g.drawString(formatMass(j + massStart, true),
									 baseX + (int)(j * xscale) - 5,
									 height - 1);
					}
				}
				
				// y軸
				for (int j=0; j<=intensityRange; j += intensityRange / 5) {
					g.setColor(gridColor2);
					// y軸を基準にグラフ背面x軸グリッド描画
					if ( i == 0 ) {
						g.drawLine(baseX,
								   baseY - (int)(j * yscale),
								   width - tmpMarginRight,
								   baseY - (int)(j * yscale));
					}
					
					// y軸を基準にグラフ側面z軸グリッド描画
					if ( i != (loopCount-1) ) {
						g.drawLine(baseX,
								   baseY - (int)(j * yscale),
								   nextBaseX,
								   nextBaseY - (int)(j * yscale));
					}
					
					g.setColor(gridColor1);
					// グラフ基準y軸目盛り描画
					g.drawLine(baseX - 2,
							   baseY - (int)(j * yscale),
							   baseX,
							   baseY - (int)(j * yscale));
					
					// グラフ基準y軸への強度文字列描画
					if (i == (loopCount-1)) {
						g.drawString(String.valueOf(j),	
									 0,
									 baseY - (int)(j * yscale));
					}
				}
				
				
				// 主要グリッド描画
				g.setColor(gridColor1);
				if ( i != (loopCount-1) ) {
					g.drawLine(baseX,
							   baseY,
							   nextBaseX,
							   nextBaseY);									// z軸
				}
				if (recTable != null && i == recTable.getSelectedRow()) {
					g.setColor(selectRecColor.darker());
				}
				else {
					g.setColor(gridColor1);
				}
				g.drawLine(baseX, tmpMarginTop, baseX, baseY);				// y軸
				g.drawLine(baseX, baseY, width - tmpMarginRight, baseY);	// x軸
				
				
				// 一番手前のグラフエリアの範囲を保持
				if (i == (recNum-1)) {
					prevGraphArea.put(LB, new Point(baseX, baseY));
					prevGraphArea.put(LT, new Point(baseX, tmpMarginTop));
					prevGraphArea.put(RT, new Point(width - tmpMarginRight, tmpMarginTop));
					prevGraphArea.put(RB, new Point(width - tmpMarginRight, baseY));					
				}
				
				// マウスでドラッグした領域を黄色の立体で囲む
				if (i == (recNum-1) && underDrag) {
					
					int xpos = Math.min(fromPos.x, toPos.x);
					int dragWidth = Math.abs(fromPos.x - toPos.x);
					
					
					// ドラッグ範囲を立体で描画
					g.setXORMode(Color.WHITE);
					g.setColor(Color.YELLOW);
					g.fillPolygon(
							new int[]{xpos+dragWidth, xpos+dragWidth, xpos, xpos},
							new int[]{tmpMarginTop, baseY, baseY, tmpMarginTop},
							4);	// 正面
					g.setColor(new Color(255, 255, 90));
					g.fillPolygon(
							new int[]{xpos+dragWidth, xpos+dragWidth+((recNum-1)*moveXPoint), xpos+((recNum-1)*moveXPoint), xpos},
							new int[]{tmpMarginTop, tmpMarginTop-((recNum-1)*moveYPoint), tmpMarginTop-((recNum-1)*moveYPoint), tmpMarginTop},
							4);	// 天面
					g.setColor(new Color(225, 225, 0));
					g.fillPolygon(
							new int[]{xpos+dragWidth, xpos+dragWidth+((recNum-1)*moveXPoint), xpos+dragWidth+((recNum-1)*moveXPoint), xpos+dragWidth},
							new int[]{tmpMarginTop, tmpMarginTop-((recNum-1)*moveYPoint), baseY-((recNum-1)*moveYPoint), baseY},
							4);	// 側面
					
					// 通常見えない立体の境界線を描画
					g.setPaintMode();
					g.setColor(new Color(200, 200, 0));
					g.drawLine(
							xpos+((recNum-1)*moveXPoint),
							tmpMarginTop-((recNum-1)*moveYPoint),
							xpos+((recNum-1)*moveXPoint),
							baseY-((recNum-1)*moveYPoint)
							);	// y軸
					g.drawLine(
							xpos+((recNum-1)*moveXPoint), 
							baseY-((recNum-1)*moveYPoint),
							xpos, 
							baseY
							);	// z軸
					g.drawLine(
							xpos+((recNum-1)*moveXPoint), 
							baseY-((recNum-1)*moveYPoint), 
							xpos+dragWidth+((recNum-1)*moveXPoint), 
							baseY-((recNum-1)*moveYPoint)
							);	// x軸
					
					// 立体の境界線を描画
					g.setColor(new Color(150, 150, 0));
					g.drawPolygon(
							new int[]{xpos + dragWidth,xpos+dragWidth, xpos, xpos},
							new int[]{tmpMarginTop, baseY, baseY, tmpMarginTop},
							4);	// 正面
					g.drawPolygon(
							new int[]{xpos+dragWidth, xpos+dragWidth+((recNum-1)*moveXPoint), xpos+((recNum-1)*moveXPoint), xpos},
							new int[]{tmpMarginTop, tmpMarginTop-((recNum-1)*moveYPoint), tmpMarginTop-((recNum-1)*moveYPoint), tmpMarginTop},
							4);	// 天面
					g.drawPolygon(
							new int[]{xpos+dragWidth, xpos+dragWidth+((recNum-1)*moveXPoint), xpos+dragWidth+((recNum-1)*moveXPoint), xpos+dragWidth},
							new int[]{tmpMarginTop, tmpMarginTop-((recNum-1)*moveYPoint), baseY-((recNum-1)*moveYPoint), baseY},
							4);	// 側面
					
					// ドラッグ範囲を保持
					dragArea = new int[]{xpos, xpos + dragWidth};
				}
			}
			
			
			PackageRecData recData = null;
			overCursorMz = new ArrayList<String>();
			
			// カーソルライン表示処理
			ArrayList<ArrayList<String>> cursorLineXInfo = new ArrayList<ArrayList<String>>();		// レコード毎のカーソルラインx座標情報
			for (int i=0; i<recNum; i++) {
				
				recData = specData.getRecInfo(i);
				
				baseX = MARGIN + (recNum-1-i) * moveXPoint;
				baseY = height - MARGIN - (recNum-1-i) * moveYPoint;

				tmpMarginTop = marginTop + (i * moveYPoint);
				tmpMarginRight = marginRight + (i * moveXPoint);
				if (tmpMarginTop > baseY) {
					tmpMarginTop = baseY;
				}
				if (width - tmpMarginRight < baseX) {
					tmpMarginRight = (width - baseX > 0) ? (width - baseX) : 0;
				}
				
				int step = stepCalc((int)massRange);
				int start = (step - (int)massStart % step) % step;
				
				// ピークがない場合
				if ( recData.getPeakNum() == 0 ) {
					continue;
				}
				
				int end, its, x, y, w;
				double mz;
				start = recData.getIndex(massStart);
				end = recData.getIndex(massStart + massRange);
				for (int j=start; j<end; j++) {
					boolean isSelectedLine = false;
					mz = recData.getMz(j);
					its = recData.getIntensity(j);
					
					x = baseX + (int)((mz - massStart) * xscale) - (int)Math.floor(xscale / 8);
					y = baseY - (int)(its * yscale);
					w = (int)(xscale / 8);
					
					// 描画パラメータ（幅）調整
					if (w < 2) {
						w = 2;
					}
					else if (w < 3) {
						w = 3;
					}
					
					// y軸より左側には描画しないように調整
					if(baseX > x) {
						w = (w - (baseX - x) > 0) ? (w - (baseX - x)) : 1;
						x = baseX + 1;
					}
					
					// 選択済ピークであるかを判定
					if (specData.getSelectedPeakNum() != 0) {
						Iterator<Double> ite = specData.getSelectedPeakList().iterator();
						while (ite.hasNext()) {
							if (String.valueOf(mz).equals(String.valueOf(ite.next()))) {
								isSelectedLine = true;
								break;
							}
						}
						// カーソルライン描画
						if ( isSelectedLine ) {
							g.setColor(Color.CYAN.darker().darker());
							g.drawLine(
									x,
									baseY,
									x + (i * moveXPoint),
									baseY - (i * moveYPoint)
									);											// カーソルピークより奥
							g.drawLine(
									x,
									baseY,
									x - ((recNum - 1 - i) * moveXPoint),
									baseY + ((recNum - 1 - i) * moveYPoint)
									);											// カーソルピークより手前
							g.drawLine(
									x - ((recNum - 1 - i) * moveXPoint),
									baseY + ((recNum - 1 - i) * moveYPoint),
									x - ((recNum - 1 - i) * moveXPoint) - 2,
									baseY + ((recNum - 1 - i) * moveYPoint) + 6
									);											// カーソルライン目印
							g.drawLine(
									x - ((recNum - 1 - i) * moveXPoint),
									baseY + ((recNum - 1 - i) * moveYPoint),
									x - ((recNum - 1 - i) * moveXPoint) + 2,
									baseY + ((recNum - 1 - i) * moveYPoint) + 6
									);											// カーソルライン目印
						}
					}
					
					
					// 拡大処理中は処理しない
					if (animationTimer == null || !animationTimer.isRunning()) {
						
						// カーソルの場所（X/Y座標）がPeakの描画エリアに含まれている場合				
						if ((cursorPoint.x >= x 
								&& cursorPoint.x <= (x + w) 
								&& cursorPoint.y >= y
								&& cursorPoint.y <= baseY)) {
							
							ArrayList<String> cursorLineX = new ArrayList<String>();	// レコード毎のカーソルラインx座標
							for (int k=0; k<recNum; k++) {
								
								if (k <= i) {
									cursorLineX.add(String.valueOf(x + ((i - k) * moveXPoint)));
								}
								else {
									cursorLineX.add(String.valueOf(x - ((k - i) * moveXPoint)));
								}
							}
							cursorLineXInfo.add(cursorLineX);
							
							// カーソルライン描画
							if ( !isSelectedLine ) {
								// 選択済ピークでない場合に描画
								g.setColor(onCursorColor.darker());
								g.drawLine(
										x,
										baseY,
										x + (i * moveXPoint),
										baseY - (i * moveYPoint)
										);											// カーソルピークより奥
								g.drawLine(
										x,
										baseY,
										x - ((recNum - 1 - i) * moveXPoint),
										baseY + ((recNum - 1 - i) * moveYPoint)
										);											// カーソルピークより手前
								g.drawLine(
										x - ((recNum - 1 - i) * moveXPoint),
										baseY + ((recNum - 1 - i) * moveYPoint),
										x - ((recNum - 1 - i) * moveXPoint) - 2,
										baseY + ((recNum - 1 - i) * moveYPoint) + 6
										);											// カーソルライン目印
								g.drawLine(
										x - ((recNum - 1 - i) * moveXPoint),
										baseY + ((recNum - 1 - i) * moveYPoint),
										x - ((recNum - 1 - i) * moveXPoint) + 2,
										baseY + ((recNum - 1 - i) * moveYPoint) + 6
										);											// カーソルライン目印
							}
							
							overCursorMz.add(String.valueOf(mz));
						}
					}
				}	// end for
			}	// end for
			
			
			// ピーク描画
			for (int i=0; i<recNum; i++) {
				
				recData = specData.getRecInfo(i);
				
				if (recData.isDisable()) {
					continue;
				}
				
				baseX = MARGIN + (recNum-1-i) * moveXPoint;
				baseY = height - MARGIN - (recNum-1-i) * moveYPoint;

				nextBaseX = baseX - moveXPoint;
				nextBaseY = baseY + moveYPoint;
				
				tmpMarginTop = marginTop + (i * moveYPoint);
				tmpMarginRight = marginRight + (i * moveXPoint);
				if (tmpMarginTop > baseY) {
					tmpMarginTop = baseY;
				}
				if (width - tmpMarginRight < baseX) {
					tmpMarginRight = (width - baseX > 0) ? (width - baseX) : 0;
				}
				
				int step = stepCalc((int)massRange);
				int start = (step - (int)massStart % step) % step;
				
				// ピークがない場合
				if ( recData.getPeakNum() == 0 ) {
					continue;
				}
				
				
				int end, its, x, y, w, h;
				double mz;
				start = recData.getIndex(massStart);
				end = recData.getIndex(massStart + massRange);
				for (int j=start; j<end; j++) {
					boolean isSelectedLine = false;
					boolean isOnLine = false;						// マウスカーソルライン上ピークフラグ
					boolean isDragArea = false;					// ドラッグ範囲内フラグ
					
					mz = recData.getMz(j);
					its = recData.getIntensity(j);
					
//					x = MARGIN + (int) ((peak - massStart) * xscale) - (int) Math.floor(xscale / 8);
					x = baseX + (int)((mz - massStart) * xscale) - (int)Math.floor(xscale / 8);
					y = baseY - (int)(its * yscale);
					w = (int)(xscale / 8);
					h = (int)(its * yscale);
					
					// 描画パラメータ（高さ、位置）調整
					if (h == 0) {
						y -= 1;
						h = 1;
					}
					// 描画パラメータ（幅）調整
					if (w < 2) {
						w = 2;
					}
					else if (w < 3) {
						w = 3;
					}
					
					// y軸より左側には描画しないように調整
					if(baseX > x) {
						w = (w - (baseX - x) > 0) ? (w - (baseX - x)) : 1;
						x = baseX + 1;
					}
					
					
					boolean inPeakArea = false;
					
					// 拡大処理中は処理しない
					if (animationTimer == null || !animationTimer.isRunning()) {
						// マウスカーソルラインの場所（X/Y座標）がPeakの描画エリアに含まれているかを判定	
						for (int k=0; k<cursorLineXInfo.size(); k++) {
							
							if (Integer.parseInt(String.valueOf(cursorLineXInfo.get(k).get(i))) == x) {
								inPeakArea = true;
								break;
							}
						}
						
						// さらに、エリア内の場合はカーソル上Peakのm/zと同じかを判定
						if (inPeakArea) {
							for (int k=0; k<overCursorMz.size(); k++) {
								if (Double.parseDouble(overCursorMz.get(k)) == mz) {
									isOnLine = true;
									break;
								}
							}
						}
					}
					
					// 選択済ピークm/zであるかの判定
					if (specData.getSelectedPeakNum() != 0) {
						Iterator<Double> ite = specData.getSelectedPeakList().iterator();
						while (ite.hasNext()) {
							if (String.valueOf(mz).equals(String.valueOf(ite.next()))) {
								isSelectedLine = true;
								break;
							}
						}
					}
					
					// ドラッグ範囲の中にPeakが含まれているかを判定
					if ( underDrag ) {
						if ( dragArea[0] + ((recNum-1-i) * moveXPoint) <= (x + w) 
								&& dragArea[1] + ((recNum-1-i) * moveXPoint) >= x) {
							
							isDragArea = true;
						}
					}
					
					
					// ピーク描画
					g.setPaintMode();
					if (isSelectedLine) {
						g.setColor(Color.CYAN.darker());						// ラインピーク選択時の色
					}
					else if (isOnLine) {
						g.setColor(onCursorColor);								// ライン上の色
					}
					else if ( isDragArea ) {									// ドラッグ範囲内の色
						if (!chgColor.isSelected() && recData.getPeakColor(j).equals(Color.RED)) {
							g.setColor(Color.MAGENTA);
						}
						else if (!chgColor.isSelected() && recData.getPeakColor(j).equals(Color.MAGENTA)) {
							g.setColor(Color.RED);
						}
						else {
							g.setColor(Color.BLUE);
						}
					}
					else if (chgColor.isSelected()) {
						g.setColor(getColor(i));								// オートカラー変更時の色
					}
					else if (y < tmpMarginTop) {
						g.setColor(Color.GRAY);									// 通常時の色(ピークがグラフ内におさまっていない場合)
					}
					else {
						g.setColor(recData.getPeakColor(j));					// 通常時の色
					}
					// ピークの描画でピークの強度が高いためにグラフ内におさまりきらない場合は、
					// グラフ内に描画できる強度まで描画する。
					if (y >= tmpMarginTop) {
						g.fill3DRect(x, y, w, h, true);
					}
					else {
						g.fill3DRect(x, tmpMarginTop, w, baseY - tmpMarginTop, true);
					}
					
					
					// m/z値を描画
					g.setFont(font2);
					boolean isMzDraw = false;
					if ( isSelectedLine ) {
						g.setColor(Color.CYAN.darker());
						if ( isOnLine ) {
							g.setFont(font1);
						}
						isMzDraw = true;
					}
					else if ( isOnLine ) {
						g.setFont(font1);
						g.setColor(onCursorColor);
						isMzDraw = true;
					}
					else if ( mzDisp.isSelected() ) {
						g.setFont(font2);
						if (!isDragArea) {
							if (its > intensityRange * 0.4 ) {
								g.setColor(Color.RED);
							}
							else if (!chgColor.isSelected()){
								g.setColor(Color.BLACK);
							}
						}
						isMzDraw = true;
					}
					else if (mzMatchDisp.isSelected()) {
						if (recData.getPeakColorType(j) != PackageRecData.COLOR_TYPE_BLACK) {
							if (!chgColor.isSelected() && !isDragArea) {
								g.setFont(font2);
								g.setColor(recData.getPeakColor(j));
							}
							isMzDraw = true;
						}
					}
					else if (its > intensityRange * 0.4) {
						g.setFont(font2);
						if (!chgColor.isSelected()) {
							g.setColor(Color.BLACK);
						}
						isMzDraw = true;
					}
					
					// グラフ内に描画できる場合のみ描画
					if (isMzDraw && y >= tmpMarginTop) {
						g.drawString(formatMass(mz, false), x, y);
					}
					
					
					// ピークの強度表示
					if (isOnLine || isSelectedLine) {
						// 強度の描画位置がグラフ内(現在の最大強度以下)の場合
						if (y >= tmpMarginTop) {
							g.setColor(onCursorColor);
							if ( isSelectedLine ) {
								g.setColor(Color.CYAN.darker());
							}
							g.drawLine(
									baseX + 4, 
									y, 
									baseX - 4, 
									y);					// 強度目盛り
							g.setColor(Color.GRAY);
							g.setFont(font2);
							if (isOnLine) {
								g.setColor(Color.DARK_GRAY);
								g.setFont(font3);
							}
							g.drawString(String.valueOf(recData.getIntensity(j)),
									baseX + 5,
									y - 1);				// 強度
						}
					}
				}	// end for
				
				// プリカーサーm/zに三角マーク付け
				if ( recData != null
						&& !recData.getPrecursor().equals("") ) {
					
					double pre = Double.parseDouble(recData.getPrecursor());
					int preX = baseX + (int)((pre - massStart) * xscale) - (int)Math.floor(xscale / 8);

					// プリカーサーm/zがグラフ内の場合のみ描画
					if ( preX >= baseX 
							&& preX <= width - tmpMarginRight ) {
						
						// プリカーサー三角の描画角度をグラフの可動にあわせて変更
						int maxGraphWidth = width - (MARGIN * 2);
						int nowGraphWidth = width - tmpMarginRight - baseX;
						int maxMovePreX = 7;
						int movePreX = 0;
						for (int j=1; j<maxMovePreX; j++) {
							if ((maxGraphWidth / maxMovePreX * j) > nowGraphWidth) {
								movePreX = maxMovePreX - j;
								break;
							}
						}
						
						int[] xp = { preX, (preX + 6 - movePreX), (preX - 6 - movePreX) };
						int[] yp = { baseY, (baseY + 5), (baseY + 5) };
						g.setColor( Color.RED );
						g.fillPolygon( xp, yp, 3 );
					}
				}
			}	// end for
		}