/*
 * @(#)RidElementPage.java
 *
 * Copyright 2001 Nomura Research Institute, LTD. All rights reserved.
 *
 * RID-X : Element
 *
 * @author  Intelligent Technology Inc.
 * @version 1.01 2001/11/07
 */
package jp.co.nri.rid.doc;

import java.awt.Color;
import java.awt.Shape;

import java.awt.geom.AffineTransform;

import java.util.Enumeration;
import java.util.Vector;

import javax.swing.JComponent;
import javax.swing.JViewport;

import org.w3c.dom.DOMException;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import jp.co.iti.fagot.ZApp;

import jp.co.iti.fagot.fob.FColor;
import jp.co.iti.fagot.fob.FInteger;

import jp.co.iti.fagot.fob.xml.XElementNS;

import jp.co.iti.fagot.geom.ZDimension;
import jp.co.iti.fagot.geom.ZPoint;
import jp.co.iti.fagot.geom.ZPath;
import jp.co.iti.fagot.geom.ZLine;
import jp.co.iti.fagot.geom.ZRectangle;

import jp.co.iti.fagot.gob.GElement;
import jp.co.iti.fagot.gob.GEllipse;
import jp.co.iti.fagot.gob.GOperation;
import jp.co.iti.fagot.gob.GobManager;
import jp.co.iti.fagot.gob.GRectangle;
import jp.co.iti.fagot.gob.GRectShape;
import jp.co.iti.fagot.gob.GPath;
import jp.co.iti.fagot.gob.GLine;
import jp.co.iti.fagot.gob.GString;
import jp.co.iti.fagot.gob.PTransform;

import jp.co.iti.fagot.doc.DocManager;
import jp.co.iti.fagot.doc.DocDocument;
import jp.co.iti.fagot.doc.DocElement;
import jp.co.iti.fagot.doc.DocGridControler;
import jp.co.iti.fagot.doc.DocPane;

import jp.co.iti.fagot.util.ZGraphicUtil;
import jp.co.iti.fagot.util.ZInstance;
import jp.co.iti.fagot.util.ZProperties;
import jp.co.iti.fagot.util.ZString;
import jp.co.iti.fagot.util.ZResource;
import jp.co.iti.fagot.util.ZDebug;

import jp.co.nri.Rid;
import jp.co.nri.rid.RUpdateManager;

import jp.co.nri.rid.environment.MessageDialog;
import jp.co.nri.rid.error.RidException;
/**
 * Rid Element(Page用)
 */
public class RidElementPage extends RidElement {

	/**
	 * デフォルトコンストラクタ
	 */
	public RidElementPage() throws DOMException {
	}

	//## IGobContainer：ヒット ########################################
	/**
	 * 要素の移動モードはなにか？
	 * @param gob リクエスト元Gob
	 * @param pt   論理座標
	 */
	public byte getPreMoveMode(GElement gob,ZPoint pt) {
	byte mode = super.getPreMoveMode(gob,pt);
	// 移動ターゲットがMapにおける親ページへの線であれば、移動モードを変更
	if ( isGobId(gob,"line") ) {
		switch ( mode ) {
		  case GOperation.MOVE:		// 移動
			mode = GOperation.NONE;
			break;

		  case GOperation.POINT:	// 点の移動
			// 終点の移動であれば、親の変更
			if ( ((GLine)gob).getMovePoint()!=1 ) {
				mode = GOperation.NONE;
				break;
			}

			// ヒットするエレメントがあれば、オプション（接続予定マーク）を表示
			String szTitle = ZInstance.prop().getProperty( Rid.PANEL_ACTIVE );
			DocPane editor = (DocPane)ZInstance.map().get(szTitle);
//			RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
//			Vector links = doc.getLinkFromPage(this);
			Enumeration elm = mFromPageForMoveGob.elements();
			while ( elm.hasMoreElements() ) {
				RidElementPage page = (RidElementPage)elm.nextElement();
				page.setHighlight(editor.getPanelId(),GOperation.NONE);
			}
			break;
		}
	}
	return mode;
	}

	/**
	 * 要素に接続するか？
	 * @param gob  リクエスト元Gob
	 * @param pt   論理座標
	 * @param obj  接続対象
	 */
	public byte getConnectMode(GElement gob,ZPoint pt,Object obj) {
	byte mode = GOperation.NONE;
	// Mapメインの場合
	if ( isGobId(gob,"map") ) {
		if ( ((GPath)gob).getPath().contains(pt) ) {
			mode = GOperation.MOVE;
		}
	} else if ( isGobId(gob,"zone") ) {
		mode = getConnectModeImpl(gob, pt, obj ) ;

	// 20020912 追加Gobにもリンクをはれるようにする
	} else if ( isGobId(gob,"add") ) {
		mode = getConnectModeImpl(gob, pt, obj ) ;
	}
	return mode;
	}

	/**
	 * ダブルクリックの動作
	 * @param gob  リクエスト元Gob
	 * @param mode クリック位置
	 */
	public void verbDblClick(GElement gob,ZPoint pt) {
	String szActive = ZInstance.prop().getProperty( Rid.PANEL_ACTIVE );
	JComponent active = (JComponent)ZInstance.map().get(szActive);
	if ( !(active instanceof DocPane) ) {
		// アクティブパネルが描画パネルでない場合は描画しない
		return;
	}
	DocPane editor = (DocPane)active;

	if ( isGobId(gob,"zone") ) {
//		PTransform trans = gob.getTransform();
//		ZRectangle rect = gob.getTransformedBounds();
		ZRectangle rect = gob.getBounds();

		ZPoint ptTTL = new ZPoint(0,getTitleHeight()+TTLIN*2);
//		ZPoint ptTTLTrans = trans.transform( ptTTL );
//		double dTTL = ptTTLTrans.getY();
		double dTTL = ptTTL.getY();

		// タイトル行のクリックの場合
		if ( pt.getY() < rect.getY()+dTTL ) {
		  	RidElementZone parent = (RidElementZone)getParentNode();
			RidElementZone root   = (RidElementZone)((DocDocument)getOwnerDocument()).getRootElement(editor.getPanelId());
			if ( parent == root ) {
				// 名前の編集
				rect.setHeight( dTTL );
				editor.setEditElement(this,rect,false);
			} else {
				// ページの描画
//				changePanel();
			}
		} else {
			// ページの描画
//			changePanel();
		}
	}
	}

	/**
	 * DOM Tree上での位置変更
	 */
	public void treeChanged() {
	updateFileAttribute();
	}

	/**
	 * Gobの削除
	 * @param gob 削除されたgob
	 */
	public void removeGob(GElement gob) {
	if ( isGobId(gob,"line") ) {
		// MAP画面において線の削除
		DocPane editor = (DocPane)ZInstance.map().get(Rid.PANEL_MAP);
		// 親を自動親に降格
		XElementNS elm = getChildElement(".ViewInfo."+editor.getPanelId(),null);
		elm.setAttribute("Type","Auto");
	} else {
		super.removeGob( gob );
	}
	}

	/**
	 * DOMから削除
	 */
	public void removeFromDocTree() {
//	ZDebug.trace(":::"+getAttribute("Key"));
	super.removeFromDocTree();
	updateLink(null);
	updateScenarioItem(null);
	}

	/**
	 * トップページの変更
	 * @param editor エディタ
	 */
	public void changeTop(DocPane editor) {
	// ルートの変更
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
	doc.setTopPage(editor.getPanelId(),getAttribute("File"));

	// ビューポートの再配置
	editor.setPaintMode(false);
	JViewport port = (JViewport)editor.getParent();
	port.doLayout();
	editor.setPaintMode(true);

	// アクセスログ最大値の設定
	((RidDocumentSite)getOwnerDocument()).requestUpdateAccessCount();

	// ルートエレメントの再計算フラグを"none"に設定
	if ( editor.getPanelId().endsWith("Circle") ) {
		DocElement root = (DocElement)doc.getRootElement( editor.getPanelId() );
		DocElement map  = (DocElement)root.getChildElement(".ViewInfo."+editor.getPanelId(),null);
		map.setAttribute("Calc","none");
	}

	// 再描画
	editor.editRestart();

	RUpdateManager.update(RUpdateManager.VIEWACTION_VIEWMAPPAGE, true);
	}


	//## IGobContainer：移動 ##########################################
	/**
	 * 移動の開始
	 * @param gob  リクエスト元Gob
	 * @param grid グリッドコントローラ
	 */
	public void moveStart(GElement gob,DocGridControler grid) {
	if ( isGobId(gob,"line") ) {
		switch ( grid.getMoveMode() ) {
		  case GOperation.MOVE:		// 移動
			// 移動はしない
			break;

		  case GOperation.POINT:	// 点の移動
			gob.moveStartGob( grid );
			break;
		}
	} else {
		super.moveStart(gob,grid);
	}
	}

	/**
	 * 移動中Pathの取得
	 * @param gob  リクエスト元Gob
	 * @param grid グリッドコントローラ
	 */
	public ZPath getMovingPath(GElement gob,DocGridControler grid) {
	if ( isGobId(gob,"line") ) {
		DocPane editor = grid.getEditor();
		ZPoint ptMove = grid.getMovePoint();
		ZPoint ptStop = ((GLine)gob).getLine().getP1Z();
		if ( grid.getMoveMode() == GOperation.POINT ) {
			// 移動点に接続コンテナがある場合は、接続コンテナから移動点を取得
			if ( findConnectPage(editor.getPanelId(),ptMove) ) {
				mConnectParent.setHighlight(editor.getPanelId(),GOperation.MOVE);
				ptMove = mConnectParent.getConnectPoint(editor.getPanelId(),GOperation.MOVE);
//				ZDebug.trace("Conn:"+ptMove);
			}

			// ヒットするエレメントがあれば、オプション（接続予定マーク）を表示
//			RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
//			Vector links = doc.getLinkFromPage(this);
			Enumeration elm = mFromPageForMoveGob.elements();
			while ( elm.hasMoreElements() ) {
				RidElementPage page = (RidElementPage)elm.nextElement();
				if ( mConnectParent != page ) {
					page.setHighlight(editor.getPanelId(),GOperation.NONE);
				}
			}
			return new ZPath( new ZLine( ptMove,ptStop ) );
		} else {
			// 全体移動の場合は描画しない
			return new ZPath( new ZLine( ptMove,ptMove ) );
		}
//  ***20020726*** Pageを全て矩形に変更
//	} else if ( isGobId( gob,"zone") ) {
//		ZRectangle rect = ((GRectShape)gob).getMovingRectGob(grid);
//		// タイプによって形が異なる
//		GRectShape gRect = new GRectShape();
//		gRect.setShape(getAttribute("PageType"));
//		gRect.setRect( rect );
//		return  gRect.getPath();

	} else if ( grid.getMoveMode() == GOperation.NEW ) {
		ZPoint ptSta= grid.getStartGrid();
		ZPoint ptMov= grid.getMoveGrid();
		if ( (ptMov.getX()-ptSta.getX()) < 10 ) { ptMov.setX(ptSta.getX()+100); }
		if ( (ptMov.getY()-ptSta.getY()) < 10 ) { ptMov.setY(ptSta.getY()+100); }
		ZPoint ptBR = new ZPoint( Math.max(ptMov.getX(),ptSta.getX()+30),
								  Math.max(ptMov.getY(),ptSta.getY()+20) );
		ZRectangle rect = new ZRectangle( ptSta, ptBR );

		// タイプによって形が異なる
//  ***20020726*** Pageを全て矩形に変更
//		GRectShape gRect = new GRectShape();
//		gRect.setShape(getAttribute("PageType"));
//		gRect.setRect( rect );
//		return  gRect.getPath();
		return  new ZPath( rect );
	}
	return super.getMovingPath(gob,grid);
	}

	/**
	 * 移動の完了
	 * @param gob  リクエスト元Gob
	 * @param grid グリッドコントローラ
	 */
	public void moveEnd(GElement gob,DocGridControler grid) {
	DocPane editor = grid.getEditor();
	String szPanelId = editor.getPanelId();
	if ( isGobId(gob,"line") ) {
		// ヒットするエレメントがあれば、オプション（接続予定マーク）を表示
		if ( findConnectPage(editor.getPanelId(),grid.getMovePoint()) ) {
			updateConnectPage(editor.getPanelId());
		}
	} else if ( isGobId(gob,"map") ) {
		// 現在位置の取得
		MapModel model = ((RidDocumentSite)getOwnerDocument()).getMapModel(szPanelId);
		double major = getMapPos( szPanelId, "Major" );
		// CircleMapで中央の時は移動しない
		if ( editor.getPanelId().endsWith("Circle") && major == 1 ) {
			return;
		}
		double minor = getMapPos( szPanelId, "Minor" );
		ZPoint ptOrg = new ZPoint(major,minor);
		ZPoint ptVw  = model.modelToView( ptOrg );
		
		// 現在座標にオフセットを追加
		ptVw.translate( grid.getOffsetGrid() );
		
		// 変換後の座標を取得
		ZPoint ptTrans = model.viewToModel( ptVw );
		setMapPos( szPanelId, "Major", ptTrans.getX() );
		setMapPos( szPanelId, "Minor", ptTrans.getY() );

		// シュリンクしている場合は移動を子ページへ波及
		XElementNS vwi = getChildElement(".ViewInfo."+szPanelId,null);
		boolean bOmission = vwi.getBooleanAttr("Omission",false);
		if ( bOmission ) {
			Enumeration elm = mToLinksForCreateGob.elements();
			while ( elm.hasMoreElements() ) {

				// リンクの取得
				RidElementLink toLink = (RidElementLink)elm.nextElement();
				RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);
				toPage.moveEndOffset( szPanelId, grid.getOffsetGrid() );
			}
		}

	} else {
		super.moveEnd( gob, grid );
		switch ( grid.getMoveMode() ) {
		  case GOperation.NEW:		// 新規作成
			RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
			doc.requestRecalcMap();
			break;
		}
	}
	}

	/**
	 * 移動の完了(Mapパネルでシュリンク済ページが移動されたとき、子ページの移動)
	 * @param szPanelId パネル識別子
	 * @param pt        移動オフセット
	 */
	public void moveEndOffset(String szPanelId, ZPoint offset) {
	MapModel model = ((RidDocumentSite)getOwnerDocument()).getMapModel(szPanelId);
	double major = getMapPos( szPanelId, "Major" );
	double minor = getMapPos( szPanelId, "Minor" );
	ZPoint ptOrg = new ZPoint(major,minor);
	ZPoint ptVw  = model.modelToView( ptOrg );
	
	// 現在座標にオフセットを追加
	ptVw.translate( offset );

	// 変換後の座標を取得
	ZPoint ptTrans = model.viewToModel( ptVw );
	setMapPos( szPanelId, "Major", ptTrans.getX() );
	setMapPos( szPanelId, "Minor", ptTrans.getY() );

	// 子ページへ波及
	Enumeration elm = mToLinksForCreateGob.elements();
	while ( elm.hasMoreElements() ) {

		// リンクの取得
		RidElementLink toLink = (RidElementLink)elm.nextElement();
		RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);
		toPage.moveEndOffset( szPanelId, offset );
	}
	}

	//## 選択 #########################################################
	/**
	 * 選択の変更
	 * @param gob  リクエスト元Gob
	 * @param bSelect 選択状態
	 */
	public boolean setSelect( GElement gob,boolean bSelect ) {
	if ( isGobId(gob,"line") ) {
		mSelectLine = bSelect;
		return bSelect;
	}
	return super.setSelect(gob,bSelect);
	}

	/**
	 * 子孫を未選択状態に設定
	 */
	public void setChildUnSelect() {
	mSelectLine = false;
	super.setChildUnSelect();
	}

	/**
	 * Ｍａｐ画面において、親ページへのリンクが選択されているか？
	 */
	public boolean isSelectLine() {
	return mSelectLine;
	}

	//## 描画 #########################################################
	/**
	 * 描画エレメントの取得(Zoneパネル)
	 *
	 * ルートの場合は、自分自身を描画しない
	 * @param szPanelId パネル識別子
	 * @param isRoot    ルートの有無
	 */
	public Vector createGobs(String szPanelId,boolean isRoot) {
	Vector gobs = new Vector();

	// 自分自身の作成
	if ( !isRoot ) {
		if ( !hasRect(szPanelId) ) {
			// 自動レイアウト
			ZPoint pt = getSpace(szPanelId);
			ZRectangle rt = new ZRectangle( pt.getX(), pt.getY(), 100, 100 );
			setRect(szPanelId,rt);
		}
		GRectangle gRect = createMainGob(szPanelId);
		gRect.setSelect(isSelect());
		gRect.setContainer(this);
		gRect.setGobId("zone");
		gRect.setMinSize(new ZDimension(30,20));
		gobs.add(gRect);
		setMainGob(szPanelId,gRect);

		// 影の描画
		gRect.addBackChildren( createShadowGobs( gRect ) );

//		***20020726*** Pageを全て矩形に変更
		String szPageType = getAttribute("PageType");
		if ( szPageType.length() > 0 && (!szPageType.equals("static")) ) {
			// RectShapeでPathを取得
			GRectShape gShape = new GRectShape();
			gShape.setShape(getAttribute("PageType"));

			// 20020807 マークを矩形の70%に縮小
			ZRectangle rt  = getRect( szPanelId );
			double dH  = rt.getHeight();
			double dW  = rt.getHeight();
			double par = 0.7;
			ZRectangle rtt = new ZRectangle( rt.getX()+dW*(1-par)/2,
											 rt.getY()+dH*(1-par)*3/4,
											 dW*par,dH*par);
			gShape.setRect( rtt );

			// Pathを作成
			GPath gPath = new GPath();
			gPath.setPath( gShape.getPath() ) ;
			gPath.getStyle().setFillColor(   gRect.getStyle().getFillColor() );
			gPath.getStyle().setStrokeColor( gRect.getStyle().getStrokeColor() );

			gRect.getStyle().setFillColor(   new FColor( Color.white ) );
			gRect.addForeChild( gPath );
		}

		// 名前の描画
		gRect.addForeChildren( createTitleGobs( szPanelId ) );
	} else {
		
		// 子供の描画
		gobs.addAll(createChildGobs(szPanelId));
	}
	return gobs;
	}

	/**
	 * 描画エレメントの取得(Mapパネル)の前処理
	 * リンクを集める
	 *
	 * @param szPanelId パネル識別子
	 */
	public void preCreateMapGobs(String szPanelId) {
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
	mToLinksForCreateGob = doc.getToLink(this,szPanelId);
	mFromPageForMoveGob  = doc.getFromPage(this);
	Enumeration elm = mToLinksForCreateGob.elements();
	while ( elm.hasMoreElements() ) {
		RidElementLink toLink = (RidElementLink)elm.nextElement();
		RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);
		toPage.preCreateMapGobs( szPanelId );
	}
	}

	/**
	 * 描画エレメントの取得(Mapパネル)
	 *
	 * @param szPanelId パネル識別子
	 * @param nHierl    作成したGobを格納する階層
	 * @param gobAll    作成したGobを格納する領域
	 */
	public void createMapGobs(String szPanelId,int nHier, Vector gobAll) {
	// 作成したGobを格納するための領域の設定
	Vector lineGobs = (Vector)gobAll.elementAt(0);
	Vector gobs = null;
	if ( gobAll.size() > nHier ) {
		gobs = (Vector)gobAll.elementAt( nHier );
	} else {
		gobs = new Vector();
		gobAll.add( gobs );
	}
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();

	// MainGob
	GPath gPath = createMapMainGob(szPanelId);
	gPath.setSelect(isSelect());
	gPath.setContainer(this);
	gPath.setGobId("map");
	setMainGob(szPanelId,gPath);
	gobs.add(gPath);

	// 影の描画
	gPath.addBackChildren( createShadowGobs( gPath ) );

	//-------------------------------------------------------------
	// タイトル領域
	//-------------------------------------------------------------
//	Vector foreChild = new Vector();
	MapModel model = doc.getMapModel(szPanelId);
	double major = getMapPos( szPanelId, "Major" );
	double minor = getMapPos( szPanelId, "Minor" );

	boolean isExist = getBooleanAttr("Exist", true );
	Shape shPage = model.createTitleShape( major,minor);
	ZPath titlePath = new ZPath( shPage );
	gPath.addForeChild( createMapTitleGob(titlePath,isExist) );

	//-------------------------------------------------------------
	// 円の描画
	//-------------------------------------------------------------
	ZRectangle rtMain = new ZRectangle( gPath.getPath().getBounds2D() );
	Color   bgColor = doc.getBackground(szPanelId);
	boolean bCircle = szPanelId.endsWith("Circle");
	if ( major == 1.0 && bCircle ) {
		XElementNS elm = findChildElement(".ViewInfo."+szPanelId,null);
		if ( elm != null ) {
			ZPoint     pt = rtMain.getCenter();
			int nDepth = elm.getIntAttr("Depth",0);
			double dOff = model.getCircleOffset();
			for ( int nIndex=nDepth-1 ; nIndex>=0 ; nIndex-- ) {
				GEllipse gEllipse = new GEllipse();
				double off = dOff*nIndex+dOff/2;
				ZPoint   ptTL = new ZPoint(pt.getX()-off,pt.getY()-off);
				ZPoint   ptBR = new ZPoint(pt.getX()+off,pt.getY()+off);
				gEllipse.setRect( new ZRectangle(ptTL,ptBR) );
				gEllipse.getStyle().setStrokeColor( new FColor( Color.white ) );
				gEllipse.setSelectable( false );
				lineGobs.add( gEllipse );
			}
		}
	}

	//-------------------------------------------------------------
	// 名前
	//-------------------------------------------------------------
	ZResource res = ZApp.getTheApp().getResource();
	String szTextType = res.getString("viewtext.Zone."+getTagName());
	String szText = getAttribute(szTextType);
	if ( szText.length() > 0 ) {
		double dIndent = 0;
		if ( getBooleanAttr("Indent",false) && szPanelId.endsWith("Hier") ) {
			dIndent = getTitleHeight();
		}
		ZRectangle rttxt = new ZRectangle( rtMain.getX(), rtMain.getY()+rtMain.getHeight()+6+dIndent,
										1000,getTitleHeight());
		GString str = new GString();
		str.setText( szText );
		str.getStyle().setFillColor( new FColor( Color.black ));
		str.setFormat( GString.SINGLE|GString.LEFT|GString.TOP );
		str.setRect( rttxt );
		gPath.addForeChild(str);
	}

	//-------------------------------------------------------------
	// シュリンク有無の判定
	//-------------------------------------------------------------
	XElementNS vwi = getChildElement(".ViewInfo."+szPanelId,null);
	boolean bOmission = vwi.getBooleanAttr("Omission",false);
	
	if ( bOmission ) {

		FInteger[] childCount = new FInteger[2];
		childCount[0] = new FInteger(0);
		childCount[1] = new FInteger(0);
		getMapChildCount(szPanelId, childCount);
		int nTotal = childCount[0].get() + childCount[1].get();
		int nExist = childCount[0].get();


		Vector omiGobs    = new Vector();
		Vector omiShadows = new Vector();

		// シュリンク影
		ZPath omiMainPath  = gPath.getPath();
		ZPath omiTitlePath = new ZPath(titlePath);

		for ( int nIndex=0 ; nIndex<nTotal ; nIndex++ ) {
			AffineTransform at = new AffineTransform(1,0,0,1,4,-3);
			ZPath transMain  = new ZPath(at.createTransformedShape(omiMainPath));
			ZPath transTitle = new ZPath(at.createTransformedShape(omiTitlePath));

			// 存在フラグ
			boolean bExist = true;
			if ( nIndex >= nExist ) {
				bExist = false;
			}

			// タイトル
			omiGobs.add( 0,createMapTitleGob(transTitle,bExist) );
			// 本体
			GPath gOmiMan = createMapMainGob(transMain,bExist);
			omiGobs.add( 0,gOmiMan );
			// 影
			omiShadows.addAll( createShadowGobs( gOmiMan ) );
			
			// パスの変更
			omiMainPath  = transMain;
			omiTitlePath = transTitle;
		}
		gPath.addBackChildren( omiShadows );
		gPath.addBackChildren( omiGobs );

	//-------------------------------------------------------------
	// 子供ページと、そのリンクの描画
	//-------------------------------------------------------------
	} else {
		ZPoint ptStart = model.getLinkPoint( major,minor );
		ZPoint ptLink  = model.getLinkHarfPoint( major,minor );

		boolean bMeDraw = false;
		GLine line = null;
		Enumeration elm = mToLinksForCreateGob.elements();
		while ( elm.hasMoreElements() ) {

			// リンクの取得
			RidElementLink toLink = (RidElementLink)elm.nextElement();
			RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

			Color colLine = toLink.getBackgroundColor();
			// 強度の調査
			String szIntensity = toLink.getAttribute("Intensity");
			float width = 0f;
			if ( szIntensity.equals("Virtual") ) {
				colLine = res.getColor("unit.color.StrongLink");
				width =2.0f;
			}
			// ユーザ設定の調査
			if ( toPage.getChildElementAttribute(".ViewInfo."+szPanelId,null,"Type").equals("User") ) {
				colLine = Color.blue;
			}
			// 存在しない場合は赤
			if ( !toLink.getBooleanAttr("Exist", true ) ) {
				colLine = res.getColor("unit.color.NotExist");
			}
			// サークルMapは直線を描画
			if ( bCircle ) {
				double majorChild = toPage.getMapPos( szPanelId, "Major" );
				double minorChild = toPage.getMapPos( szPanelId, "Minor" );
				ZPoint ptStartChild = model.getLinkPoint( majorChild,minorChild );

				line = new GLine();
				line.getStyle().setStrokeColor( new FColor( colLine ));
				line.setLine( new ZLine(ptStartChild,ptStart) );
				line.setSelect(toPage.isSelectLine());
				line.setContainer(toPage);
				line.setGobId("line");
				lineGobs.add(line);
			} else {
				if ( !bMeDraw ) {
					// 自分からの引き出し線を描画
					line = new GLine();
					line.getStyle().setStrokeColor( new FColor( Color.black ));
					line.setLine( new ZLine(ptStart,ptLink) );
					line.setSelectable( false );
					lineGobs.add(line);
					bMeDraw = true;
				}
				double majorChild = toPage.getMapPos( szPanelId, "Major" );
				double minorChild = toPage.getMapPos( szPanelId, "Minor" );
				ZPoint ptStartChild = model.getLinkPoint( majorChild,minorChild );
				ZPoint ptLinkChild  = model.getLinkHarfPoint( major,minorChild);

				// 子供からの引き出し線を描画
				// 選択可能なGobとして登録
				line = new GLine();
				line.getStyle().setStrokeColor( new FColor( colLine ));
				if ( width != 0f ) {
					line.getStyle().getStroke().getWidth().set(width);
				}
				line.setLine( new ZLine(ptStartChild,ptLinkChild) );
				line.setSelect(toPage.isSelectLine());
				line.setContainer(toPage);
				line.setGobId("line");
				lineGobs.add(line);

				// 横線を描画
				line = new GLine();
				line.getStyle().setStrokeColor( new FColor( Color.black ));
				line.setLine( new ZLine(ptLink,ptLinkChild) );
				line.setSelectable( false );
				lineGobs.add(line);

			}
			// 子供を描画
			toPage.createMapGobs( szPanelId, nHier+1, gobAll );
		}
	}

	// アクセスログの追加有無の判定
	boolean bViewAccess = res.getBoolean("view.Page.AccessCount");
	if ( bViewAccess && szPanelId.endsWith("Site") ) {
		AccessCounts acc = new AccessCounts( getAttribute("AccessCount") );
		Shape[] sha = model.createAccessShapes( major,minor,acc );
		ZProperties prop = DocManager.loadProperty( DocManager.DOCUMENT );
		if ( sha != null ) {
			int nMaxColor = -1 ;
			Color col = res.getColor("unit.color.AccessCount");
			for ( int nAt=0 ; nAt < sha.length ; nAt++ ) {
				// 色の決定
				col = null;
				if ( nMaxColor == -1 ) {
					String szKey = "accesslog.color."+nAt;
					if ( prop.getProperty( szKey ) == null ) {
						nMaxColor = nAt;
					} else {
						col = prop.getColor(szKey);
					}
				}
				if ( col == null ) {
					if ( nMaxColor == 0 ) {
						col = res.getColor("unit.color.AccessCount");
					} else {
						int nColAt  = nAt % nMaxColor ;
						int nRotate = nAt / nMaxColor ;
						col = prop.getColor("accesslog.color."+nColAt);
					}
				}

				// パスの生成
				GPath gAccess = new GPath();
				gAccess.setPath( new ZPath( sha[nAt] ) );
				gAccess.getStyle().setFillColor( new FColor( col ));
				gAccess.getStyle().setStrokeColor( new FColor( Color.white ));
				gPath.addForeChild( gAccess );
			}
		}
	}
	}

	/**
	 * アクセス数最大値の取得
	 * リンク先ページも含めて階層配下の最大値を求める
	 * @param szPanelId パネル識別子
	 * @param bLogList  表示する配列
	 */
	public AccessCounts getMaxAccessCount(String szPanelId,boolean[] bLogList ) {
	AccessCounts acc = new AccessCounts(getAttribute("AccessCount"),bLogList);
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();

	// シュリンク有無の判定
	XElementNS vwi = getChildElement(".ViewInfo."+szPanelId,null);
	boolean bOmission = vwi.getBooleanAttr("Omission",false);
	
	if ( !bOmission ) {
		Enumeration elm = mToLinksForCreateGob.elements();
		while ( elm.hasMoreElements() ) {

			// リンクの取得
			RidElementLink toLink = (RidElementLink)elm.nextElement();
			RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

			// 子供ページから取得
			AccessCounts acc2 = toPage.getMaxAccessCount( szPanelId,bLogList );
			acc.margeMax( acc2 );
		}
	}
	return acc;
	}

	/**
	 * 描画エレメントの取得
	 *
	 * ルートの場合は、自分自身を背景として描画する
	 * @param szPanelId パネル識別子
	 * @param isRoot    ルートの有無
	 */
	public Vector createSkeltonGobs(String szPanelId,boolean isRoot) {
	Vector gobs = new Vector();

	GRectangle gRect = createMainGob(szPanelId);
	gRect.setPaintIfSmall(true);
	gobs.add(gRect);

	return gobs;
	}

	/**
	 * 描画エレメントの取得
	 *
	 * ルートの場合は、自分自身を背景として描画する
	 * @param szPanelId パネル識別子
	 * @param isRoot    ルートの有無
	 */
	public Vector createMapSkeltonGobs(String szPanelId) {
	Vector gobs = new Vector();
	GPath gPath = createMapMainGob(szPanelId);
	gPath.setPaintIfSmall(true);
	gobs.add(gPath);

	XElementNS vwi = getChildElement(".ViewInfo."+szPanelId,null);
	boolean bOmission = vwi.getBooleanAttr("Omission",false);
	
	if ( !bOmission ) {
//		RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
//		Vector pages = doc.getLinkToPage(this);
		Enumeration elm = mToLinksForCreateGob.elements() ;
		while ( elm.hasMoreElements() ) {

			// リンクの取得
			RidElementLink toLink = (RidElementLink)elm.nextElement();
			RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

			// 通常、toPageがnullの場合は、リンクが削除されるはずだが、
			// 再描画のタイミングで直前のmToLinksForCreateGobが残っている場合もある。
			if ( toPage != null ) {
				gobs.addAll(toPage.createMapSkeltonGobs(szPanelId));
			}
		}
	}
	return gobs;
	}

	/**
	 * 描画エレメントの取得
	 * @param szPanelId パネル識別子
	 */
	protected GRectangle createMainGob(String szPanelId) {
//  ***20020726*** Pageを全て矩形に変更
//	GRectShape gRect = new GRectShape();
//	gRect.setShape(getAttribute("PageType"));
	GRectangle gRect = new GRectangle();

	// 矩形の設定
	ZRectangle rect = getRect( szPanelId );
	gRect.setRect( rect );
	// 背景色の設定
	Color col = getBackgroundColor();
	gRect.getStyle().setFillColor( new FColor( col ));

	// 枠色の設定
	ZResource res = ZApp.getTheApp().getResource();
	boolean isExist = getBooleanAttr("Exist", true );
	col = res.getColor("unit.color."+((isExist)?"":"Not")+"Exist");
	gRect.getStyle().setStrokeColor( new FColor( col ) );
	return gRect;
	}

	/**
	 * タイトルの作成
	 * @param szPanelId パネル識別子
	 */
	public Vector createTitleGobs(String szPanelId) {
	return super.createTitleGobs( szPanelId ) ;
	}

	/**
	 * 描画エレメントの取得(Map用メイン)
	 * @param szPanelId パネル識別子
	 */
	protected GPath createMapMainGob(String szPanelId) {
	MapModel model = ((RidDocumentSite)getOwnerDocument()).getMapModel(szPanelId);
	double major = getMapPos( szPanelId, "Major" );
	double minor = getMapPos( szPanelId, "Minor" );

	Shape shPage = model.createPageShape( major,minor,getAttribute("PageType"));
	ZPath path = new ZPath(shPage);
	boolean isExist = getBooleanAttr("Exist", true );
	return createMapMainGob( path,isExist ) ;
	}

	/**
	 * 描画エレメントの取得(シナリオ)
	 * @param szPanelId パネル識別子
	 */
	protected ZPath getMapScenarioPath(String szPanelId) {
	MapModel model = ((RidDocumentSite)getOwnerDocument()).getMapModel(szPanelId);
	double major = getMapPos( szPanelId, "Major" );
	double minor = getMapPos( szPanelId, "Minor" );

	// パスの作成
	Shape shPage = model.createScenarioShape( major,minor);
	ZPath path = new ZPath(shPage);

	return path;
	}

	/**
	 * 描画エレメントの取得(Map用メイン)
	 * @param path    形状
	 * @param isExist 存在有無
	 */
	protected GPath createMapMainGob( ZPath path, boolean isExist ) {
	GPath gpath = new GPath();
	// 領域の設定
	gpath.setPath( path );
	// 背景色の設定
	Color col = getBackgroundColor();
	gpath.getStyle().setFillColor( new FColor( col ));

	// 枠色の設定
	ZResource res = ZApp.getTheApp().getResource();
	col = res.getColor("unit.color."+((isExist)?"":"Not")+"Exist");
	gpath.getStyle().setStrokeColor( new FColor( col ));
	return gpath;
	}

	/**
	 * 描画エレメントの取得(Map用タイトル)
	 * @param path    形状
	 * @param isExist 存在有無
	 */
	protected GPath createMapTitleGob( ZPath path, boolean isExist ) {
	GPath gTitle = new GPath();
	// 領域の設定
	gTitle.setPath( path );
	// 背景色の設定
	Color col = ((RidElement)getParentNode()).getBackgroundColor();
	gTitle.getStyle().setFillColor( new FColor( col ));

	// 枠色の設定
	ZResource res = ZApp.getTheApp().getResource();
	col = res.getColor("unit.color."+((isExist)?"":"Not")+"Exist");
	gTitle.getStyle().setStrokeColor( new FColor( col ));
	return gTitle;
	}

	/**
	 * Map画面における子Pageの数を計算する
	 * @param szPanel パネル識別子
	 * @param count   子ページのカウントの配列(0番目:exist=true,1番目:exist=false)
	 */
	protected void getMapChildCount(String szPanelId, FInteger[] count ) {
	Enumeration elm = mToLinksForCreateGob.elements();
	while ( elm.hasMoreElements() ) {

		// リンクの取得
		RidElementLink toLink = (RidElementLink)elm.nextElement();
		RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

		// 子供が見つかったので、子供に計算させる
		toPage.getMapChildCount(szPanelId,count);
		boolean isExist = toPage.getBooleanAttr("Exist", true );
		if ( isExist ) {
			count[0].increment();
		} else {
			count[1].increment();
		}
	}
	}

	//## ＭＡＰ：再計算 ###############################################
	/**
	 * MAP情報のクリア
	 * @param szPanelId パネル識別子
	 */
	public void clearMap(String szPanelId) {
	wMajorCalcing = false;
	wMajorTmp = 0;
	wMinorTmp = 0;
	wTopId    = 0;
	wMajorPre = getMapPos( szPanelId, "Major" );
	wMinorPre = getMapPos( szPanelId, "Minor" );

	wFromLink  = null;
	wFromPage  = null;
	wUserSettingParent = null;
	wFromLinks = new Vector();
	// ユーザ設定の親があれば、ユーザ設定の親を保存し、wFromLinksをnullに設定
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
	String szParent = getMapParent( szPanelId, "User" );
	if ( szParent.length()>0 ) {
		wUserSettingParent = (RidElementPage)doc.findChildElementInZone("PageUnit",szParent);
	}
	
	wToLinksForRecalcMap = doc.getToLink( this, null );
	}

	/**
	 * 仮Map番号の付与と、親決め
	 * @param szPanelId  パネル識別子
	 * @param fromLink   親ページへのリンク
	 * @param isZoneBase ゾーン優先アルゴリズム
	 * @param nTop       トップレベルID
	 */
	public boolean recalcMapMajor(String szPanelId,RidElementLink fromLink, boolean isZoneBase, int nTop) {
	/*** Debug ***/	boolean bDebug = false;
//	/*** Debug ***/	if ( getAttribute("File").equals("map_osaki.html") ) bDebug = true;
	boolean calced = false;
	// 計算中の場合は、再計算しない
	if ( wMajorCalcing ) {
		return calced;
	}
	wMajorCalcing = true;

	// 新しいメジャー番号の設定
	// 親なしの場合は、majorを1に設定 親がある場合は、親＋１
	double         nMajor   = 1;
	RidElementPage fromPage = null;
	if ( fromLink != null ) {
		fromPage = (RidElementPage)fromLink.getLinkFromElement(this);
		nMajor   = fromPage.wMajorTmp+1;
	}

	// 初回呼び出し時は、wMajorTmp == 0 なので計算する
	if ( wMajorTmp == 0 ) {
		calced = true;

	// すでにルートになっていれば、 							wFromLink == null なので親は変えない
	// すでに親が決まっていて、ルートからの再呼び出しであれば、	fromLink == null なので親は変えない
	} else if ( wFromLink != null && fromLink != null ) {
		if ( isZoneBase ) {
			RidElementLink newFromLink = null;
			if ( wFromLink == fromLink ) {
				// 現在親であるページが状態の変更された
	/*** Debug ***/if(bDebug){ZDebug.trace("同一リンクの再計算:"+nMajor+","+wMajorTmp);}
				// 階層が変わったので必ず再計算する（ベストが変わらない場合も再計算する）
				// 階層が変わらない場合は再計算しない
				if ( nMajor != wMajorTmp ) {
					newFromLink = recalcBestLink(wFromLinks);
					if ( newFromLink == null ) {
						newFromLink = fromLink;
					}
				}

			// 現在の親へのリンクと異なるリンクから呼び出された場合
			} else {
				// リンクリストに今回のリンクを追加する
				if ( !wFromLinks.contains( fromLink ) ) {
					wFromLinks.add( fromLink );
				}

				RidElementPage oldParent = (RidElementPage)wFromLink.getLinkFromElement(this);
				RidElementPage newParent = (RidElementPage)fromLink.getLinkFromElement(this);
				if ( oldParent == newParent ) {
					// 親ページから複数のリンクが張られていた場合現在親であるページが状態の変更された
					// 階層が変わらない場合は再計算しない
					if ( nMajor != wMajorTmp ) {
						// 階層が変わった可能性があるので再計算する
						newFromLink = recalcBestLink(wFromLinks);
						fromLink = null;
					}

				} else {
					// 現在親とは異なるページが親候補になったので、現在親からのリンクと、新しい親からのリンクのどちらを優先するか調査
					Vector links = new Vector();
					links.add( fromLink );	// 今回のリンク
					newFromLink = recalcBestLink(links);
				}
			}
			
			// 再計算する場合
			if ( newFromLink != null ) {
				calced = true;
				fromLink = newFromLink;
				fromPage = (RidElementPage)fromLink.getLinkFromElement(this);
				nMajor   = fromPage.wMajorTmp+1;
	/*** Debug ***/if(bDebug){ZDebug.trace("ベスト親の再設定:"+fromPage.getAttribute("File")+" nMajor:"+nMajor);}
			}

		} else {
			// 新しいメジャー番号が定義済みメジャー番号より小さい時は再計算
			if ( nMajor < wMajorTmp ) {
				calced = true;
			}
		}
	}

	// Map番号再計算
	if ( calced ) {
		// Major番号の設定
		wMajorTmp = nMajor;
		wTopId    = nTop;
		wFromLink = fromLink;
		wFromPage = fromPage;
	/*** Debug ***/if(bDebug){ZDebug.trace("計算開始:"+nMajor+":"+((fromPage!=null)?fromPage.getAttribute("File"):""));}

		// リンク先のページのMap番号を設定する
//		Vector links = ((RidDocumentSite)getOwnerDocument()).getToLink(this);
		Enumeration elm = wToLinksForRecalcMap.elements() ;
		while ( elm.hasMoreElements() ) {
			RidElementLink toLink = (RidElementLink)elm.nextElement();
			RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);
			toPage.recalcMapMajor(szPanelId,toLink,isZoneBase,nTop);
		}
//		ZDebug.trace("計算完了："+getAttribute("Key")+"("+wMajorTmp+","+wMinorTmp+") ");
//		if ( wParent != null ) {
//			ZDebug.trace("     親は"+wParent.getAttribute("File"));
//		}
	}
//	ZDebug.trace("計算済み："+getAttribute("Key")+"("+wMajorTmp+","+wMinorTmp+")");

	wMajorCalcing = false;
	return calced;
	}

	/**
	 * 最適なリンクを計算する
	 * @param fromLinks  親ページからのリンク群
	 */
	public RidElementLink recalcBestLink(Vector links) {
	// 初期設定
	String myZone   = ((DocElement)getParentNode()).getAttribute("File");
	RidElementLink oldLink   = wFromLink;
	RidElementPage oldParent = (RidElementPage)oldLink.getLinkFromElement(this);

	if ( wUserSettingParent == oldParent ) {
		// すでにユーザ設定が有効になっているので、再計算しない
		return null;
	}

	// 他のリンクと比較
	Enumeration elm = links.elements();
	while ( elm.hasMoreElements() ) {
		RidElementLink newLink   = (RidElementLink)elm.nextElement();
		RidElementPage newParent = (RidElementPage)newLink.getLinkFromElement(this);

		// ユーザ設定の調査
		if ( wUserSettingParent == newParent ) {
			return newLink;
		}

		// リンク強度の比較
		String szOldIntensity = oldLink.getAttribute("Intensity");
		String szNewIntensity = newLink.getAttribute("Intensity");
		int oldIntensity = 0;
		if ( szOldIntensity.equals("Virtual") )			{oldIntensity=1;}
		int newIntensity = 0;
		if ( szNewIntensity.equals("Virtual") )			{newIntensity=1;}
		if ( oldIntensity < newIntensity ) {
			oldLink = newLink;
		} else if ( oldIntensity == newIntensity ) {
			boolean bTopCheck = false;
			// 強度は同じなので、ゾーンの比較
			oldParent = (RidElementPage)oldLink.getLinkFromElement(this);
			String oldZone = ((DocElement)oldParent.getParentNode()).getAttribute("File");
			String newZone = ((DocElement)newParent.getParentNode()).getAttribute("File");

			// ベスト親と新しい親ともに同一ゾーンの場合は、トップレベルが小さい方を優先
			if ( myZone.equals( oldZone ) && myZone.equals( newZone ) ) {
				bTopCheck = true;

			// ベスト親のゾーンが異なり、新しい親とゾーンが同じであれば、再計算
			} else if ( myZone.equals( newZone ) ) {
				oldLink = newLink;

			// どちらもゾーンが異なれば、トップレベルが小さい方を優先
			} else {
				bTopCheck = true;
			}

			// トップレベルの比較
			if ( bTopCheck ) {
				if ( oldParent.wTopId > newParent.wTopId ) {
					oldLink = newLink;

				} else if ( oldParent.wTopId == newParent.wTopId ) {
					// トップレベルが同じであればMajorの小さい方が優先
					if ( oldParent.wMajorTmp > newParent.wMajorTmp ) {
						oldLink = newLink;
					}
				}
			}
		}
	}
	
	// 現在のリンクが最適なリンクであれば再計算しない
	if ( oldLink == wFromLink ) {
		return null;
	}
	return oldLink;
	}

	/**
	 * 仮Minor番号の付与
	 * @param szPanelId  パネル識別子
	 * @param nMinor     開始minor 番号
	 * @param bIndent    字下げ有無
	 */
	public MapMinorTree recalcMapMinor(String szPanelId,double nMinor, boolean bIndent) {
	// 偶数番目なら、タイトルを１段下げる
	wTitleIndent = bIndent;
//	ZDebug.trace("Name:"+getAttribute("Name")+" No:"+nMinor+" ident:"+wTitleIndent);

	// 子供のページを検索する
	Vector childPages = new Vector();
	Enumeration elm = wToLinksForRecalcMap.elements() ;
	while ( elm.hasMoreElements() ) {

		// リンクの取得
		RidElementLink toLink = (RidElementLink)elm.nextElement();
		RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

		if ( toPage.wFromPage == this ) {
			childPages.add( toPage ) ;
		}
	}

	// マイナー番号を付与
	MapMinorTree tree = null;
	if ( childPages.size() > 0 ) {
		tree = ((RidDocumentSite)getOwnerDocument()).recalcMapMinor(szPanelId, childPages, nMinor,bIndent);
		wMinorTmp = tree.getChildHarf();
	} else {
		tree = new MapMinorTree();
		tree.setLastIndent( bIndent );
		wMinorTmp = nMinor;
	}
	tree.add( wMinorTmp );
	return tree;
	}

	/**
	 * 仮Minor番号の移動
	 * @param szPanelId  パネル識別子
	 * @param offset     移動距離
	 */
	public MapMinorTree recalcMapMinorMove(String szPanelId,double offset) {
	// 子供のページを検索する
	Vector childPages = new Vector();
	MapMinorTree tree = null;
	Enumeration elm = wToLinksForRecalcMap.elements() ;
	while ( elm.hasMoreElements() ) {
		// リンクの取得
		RidElementLink toLink = (RidElementLink)elm.nextElement();
		RidElementPage toPage = (RidElementPage)toLink.getLinkToElement(this);

		if ( toPage.wFromPage == this ) {
			MapMinorTree tree2 = toPage.recalcMapMinorMove(szPanelId,offset);
			if ( tree == null ) {
				tree = tree2;
			} else {
				tree.marge( tree2 );
			}
		}
	}

	wMinorTmp += offset;
	if ( tree == null ) {
		tree = new MapMinorTree();
	}
	tree.add( wMinorTmp );
	return tree;
	}

	/**
	 * Map番号の設定(最後)
	 * 計算済みmajor,minorをposに設定する
	 * @param szPanelId  パネル識別子
	 * @param dTotal minor番号の最大値
	 */
	public ZRectangle recalcMapEnd(String szPanelId, double dTotal){
	setMapPos(szPanelId, "Major", wMajorTmp);
	if ( szPanelId.endsWith("Circle") ) {
//		setMapPos(szPanelId, "Minor", (2*Math.PI/(dTotal+1))*wMinorTmp );
		setMapPos(szPanelId, "Minor", (2*Math.PI/dTotal)*wMinorTmp );
	} else {
		setMapPos(szPanelId, "Minor", wMinorTmp-(dTotal/2) );
	}

	// 親がユーザ指定の親であれば、設定しない
	String szAttrParent = getMapParent( szPanelId, "User" );
	String szLinkParent = (wFromPage==null)?"root":wFromPage.getAttribute("File");
	if ( szAttrParent.length() == 0 || !szAttrParent.equals(szLinkParent) ) {
		setMapParent( szPanelId, "Auto", szLinkParent );
	}
//	ZDebug.trace("complete:"+getAttribute("File")+"("+wMajorTmp+","+wMinorTmp+")");

	// 字下げの設定
	setBooleanAttr("Indent", wTitleIndent );

	// 計算が完了したら、描画する矩形を返す
	// 20020305追加
	MapModel model = ((RidDocumentSite)getOwnerDocument()).getMapModel(szPanelId);
	double major = getMapPos( szPanelId, "Major" );
	double minor = getMapPos( szPanelId, "Minor" );
	Shape shPage = model.createPageShape( major,minor,getAttribute("PageType"));
	return new ZRectangle(shPage);
	}

	//## ＭＡＰ #######################################################
	/**
	 * Map位置の取得
	 * @param szPanelId パネル識別子
	 * @param szType    タイプ
	 */
	public double getMapPos(String szPanelId, String szType) {
	XElementNS elm = findChildElement(".ViewInfo."+szPanelId,null);
	if ( elm != null ) {
		return elm.getDoubleAttr(szType,0);
	}
	return 0;
	}

	/**
	 * Map位置の設定
	 * @param szPanelId パネル識別子
	 * @param szType    タイプ
	 * @param value     値
	 */
	public void setMapPos(String szPanelId, String szType, double value) {
	XElementNS elm = getChildElement(".ViewInfo."+szPanelId,null);
	elm.setDoubleAttr(szType,value);
	}

	/**
	 * Map親の取得
	 * @param szPanelId パネル識別子
	 * @param szType    タイプ{"User|Auto"}
	 */
	public String getMapParent(String szPanelId, String szType) {
	XElementNS elm = findChildElement(".ViewInfo."+szPanelId,null);
	if ( elm != null ) {
		if ( szType == null ) {
			return elm.getAttribute("Parent");
		} else if ( elm.getAttribute("Type").equals(szType) ) {
			return elm.getAttribute("Parent");
		}
	}
	return "";
	}

	/**
	 * Map親の設定
	 * @param szPanelId パネル識別子
	 * @param szType    タイプ
	 * @param value     値
	 */
	public void setMapParent(String szPanelId, String szType, String value) {
	XElementNS elm = getChildElement(".ViewInfo."+szPanelId,null);
	elm.setAttribute("Type",szType);
	elm.setAttribute("Parent",value);
	}

	//## リンク情報 ###################################################
	/**
	 * 接続できるコンテナを探す。
	 * @param szPanelId パネル識別子
	 * @param pt        座標
	 */
	protected boolean findConnectPage(String szPanelId, ZPoint pt) {
	RidDocumentSite doc = (RidDocumentSite)getOwnerDocument();
	// ヒットするコンテナが存在するか？
	Enumeration elm = GobManager.elements(szPanelId,GobManager.ALL);
	while ( elm.hasMoreElements() ) {
		GElement item = (GElement)elm.nextElement();
		byte pos = item.getConnectMode(pt, this);
		if ( pos != 0 ) {
			RidElementPage container = (RidElementPage)item.getContainer();
			if ( container != null && container != this ) {

				DocElement linklist = (DocElement)((DocElement)doc.getDocumentElement()).findChildElement(".Link",null);
				if ( linklist != null ) {
					NodeList list = linklist.getChildNodes();
					for ( int nAt=0 ; nAt<list.getLength() ; nAt++ ) {
						Node child = list.item(nAt);
						if ( child instanceof RidElementLink ) {
							RidElementLink linkUnit = (RidElementLink)child;
							RidElement toPage = linkUnit.getLinkToElement(container);
							if ( toPage == this ) {
								mConnectParent = container;
								return true;
							}
						}
					}
				}
/*
				// ヒットしたページから自分に向かってリンク線があるか？
				Vector linkTos = doc.getLinkToPage( container );
				Enumeration elmLink = linkTos.elements();
				while ( elmLink.hasMoreElements() ) {
					if ( elmLink.nextElement() == this ) {
						mConnectParent = container;
						return true;
					}
				}
*/
			}
		}
	}
	mConnectParent = null;
	return false;
	}

	/**
	 * 検出済の接続できるコンテナをDOMに反映する
	 * @param szPanelId パネル識別子
	 */
	protected void updateConnectPage(String szPanelId) {
	setMapParent(szPanelId,"User",mConnectParent.getAttribute("File"));
	}

	//## 編集 #########################################################
	/**
	 * 文字列の設定
	 */
	public void setText(String szText) {
	setAttribute("Name",szText);
	if ( !szText.equals( getAttribute("Name") ) ) {
		RidException err = (RidException)ZInstance.map().get("setAttribute");
		MessageDialog.showError(err.getMessage());
	}
	}

	/**
	 * 文字列の取得
	 */
	public String getText() {
	return 	getAttribute("Name");
	}

	//## SubTag #######################################################
	/**
	 * サブタグの設定
	 * Docbarから生成するときにattributeも固有のものにするためのキー
	 * @param szText サブタグ
	 */
	public void setSubTag(String szText) {
	setAttribute("PageType",szText);
	}

	//## アトリビュート################################################
	/**
	 * Map画面において、親ページへのリンクライン選択の有無
	 */
	protected boolean mSelectLine = false;

	/**
	 * 親変更時の一時親エレメント
	 */
	protected RidElementPage mConnectParent = null;

	/**
	 * CreateGob用ハッシュデータ
	 */
	protected Vector mToLinksForCreateGob = new Vector();

	/**
	 * MoveGob用ハッシュデータ
	 */
	protected Vector mFromPageForMoveGob = new Vector();

	//## アトリビュート：再計算用一時データ ###########################
	/**
	 * Map再計算中フラグ
	 */
	public boolean wMajorCalcing = false;
	/**
	 * Map再計算中のMajor番号
	 */
	public double wMajorTmp = 0;
	/**
	 * Map再計算中のMinor番号
	 */
	public double wMinorTmp = 0;
	/**
	 * Map再計算中のTopLevelId
	 */
	public double wTopId = 0;
	/**
	 * Map再計算前のMajor番号
	 */
	public double wMajorPre = 0;
	/**
	 * Map再計算前のMinor番号
	 */
	public double wMinorPre = 0;
	/**
	 * Map再計算中の仮親へのリンク
	 */
	public RidElementLink wFromLink = null;
	/**
	 * Map再計算中の仮親
	 */
	public RidElementPage wFromPage = null;
	/**
	 * Map再計算中の仮親へのリンク群
	 */
	public Vector wFromLinks   = null;
	/**
	 * ユーザ指定の親
	 */
	public RidElementPage wUserSettingParent = null;
	/**
	 * HierMapにおけるタイトルの字下げ
	 */
	protected boolean wTitleIndent = false;

	/**
	 * RecalcMap用ハッシュデータ
	 */
	protected Vector wToLinksForRecalcMap = new Vector();

}
