//----------------------------------------------------------------------
//	NonogramApplet.java
//----------------------------------------------------------------------
//	ののぐらむ（お絵書きロジック、アートロジック、etc）
//
//	Copyright(C) 1996 Hirofumi Fujiwara 
//	本プログラムは、改造も含め、その商用利用は禁止します。
//----------------------------------------------------------------------

import java.awt.*;
import java.applet.*;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.net.*;

//================================================================================
//	ののぐらむ（アプレット）
//================================================================================
public class NonogramApplet extends Applet {
	Nonogram app;		// アプリケーション（ののぐらむ）
	Problem  problem;	// 問題の一時保存
	String   prob;		// 問題ファイル名


	boolean	 first = true;
	Font     btnfont = new Font( "Helvetica", 0, 20 );

	//----------------------------------------
	//	初期化
	//----------------------------------------
	public void init() {
		problem = new Problem( this );

		prob = getParameter("problem");

		System.out.println( "-- java/try/test check Sat Feb 14 18:30:25 JST 1998 --" );
		if( prob != null ) {
			problem.loadprob( prob );
		}

		setLayout( new BorderLayout() );
		Button	btn = new Button( "Start" );
		btn.setFont( btnfont );
		add( "Center", btn );
	}

	//----------------------------------------
	//	ストップ
	//----------------------------------------
	public void stop() {
		app.sizeFrame.hide();
		app.hide();
	}

	//----------------------------------------
	//	ボタンが押された時の処理
	//----------------------------------------
	public boolean action( Event evt, Object obj ) {
		if( "Start".equals(obj) ) {
			if( app == null ) {
				app = new Nonogram( this );
				app.makePanels();
			}

			app.show();

			if( prob != null && first ) {
				first = false;
				app.showforced( "Play" );
				app.playPanel.setprob( problem );
			}
		}
		return true;
	}
}

//================================================================================
//	問題データの保存
//================================================================================
class Problem {
	NonogramApplet applet;
	boolean	valid;
	String	filename;
	int	width;
	int	height;
	int	vdepth;
	int	hdepth;
	int	vlines[][];
	int	hlines[][];

	//----------------------------------------
	//	構築子
	//----------------------------------------
	Problem( NonogramApplet ap ) {
		applet = ap;
		valid = false;
	}

	//----------------------------------------
	//	リサイズ
	//----------------------------------------
	void resize( Nonogram app ) {
		app.bdwidth  = width;
		app.bdheight = height;
		app.playPanel.vdepth = vdepth;
		app.playPanel.hdepth = hdepth;
	}

	//----------------------------------------
	//	問題のロード
	//----------------------------------------
	void loadprob( String fname ) {
		valid = false;
		filename = fname;

		URL		url;
		DataInputStream file;
		try {
			System.err.println( "problem file : getCodeBase()" );
			url = new URL( applet.getCodeBase(), filename );
			file = new DataInputStream( url.openStream() );
		} catch( MalformedURLException e ) {
			applet.showStatus( "file name error : " + filename );
			return;
		} catch( IOException e ) {
			applet.showStatus( "file open error : " + filename );
			return;
		}

		int	w, h, wd, hd;
		w = h = 20; 
		wd = hd = 10;
		int vals[] = new int[100];
		int valn   = 0;
		int idx = 0;

		String line;

		try {

		    nextline:
			for(;;) {
				line=file.readLine();
				String tk;

				if( line == null )
					break;
				if( '#' == line.charAt(0) )
					continue;
				if( ';' == line.charAt(0) )
					continue;

				// System.out.println( line );

				StringTokenizer st = new StringTokenizer(line);

				try {
					tk = st.nextToken();

					if( tk.equals("size") ) {
						tk = st.nextToken();
						width = (Integer.valueOf(tk)).intValue();
						tk = st.nextToken();
						height = (Integer.valueOf(tk)).intValue();
						continue nextline;
					}
					if( tk.equals("depth") ) {
					//	tk = st.nextToken();
					//	vdepth = (Integer.valueOf(tk)).intValue();
					//	tk = st.nextToken();
					//	hdepth = (Integer.valueOf(tk)).intValue();
						continue nextline;
					}

					if( tk.equals("begin") ) {
						vlines = new int[width][0];
						hlines = new int[height][0];

						continue nextline;

					}
					if( tk.equals("end") ) {
						break nextline;
					}

					// System.out.println( "["+idx+"]"+line );

					valn   = 0;
					if( ! tk.equals( "-" ) )  {

						while( tk != null ) {
							// System.out.println( valn+")"+tk );
							vals[valn] = (Integer.valueOf(tk)).intValue();
							++valn;
							if( ! st.hasMoreTokens() )
								break;
							tk = st.nextToken();
						}
					}

					if( idx < width ) {
						vlines[idx] = new int[valn];
						for( int i=0; i<valn; ++i )
							vlines[idx][i] = vals[i];
					} else {
						int y = idx-width;
						hlines[y] = new int[valn];
						for( int i=0; i<valn; ++i )
							hlines[y][i] = vals[i];
					}
					// System.out.print( "idx:");
					// for( int i=0; i<valn; ++i ) {
					//	System.out.print( " "+vals[i] );
					// }
					// System.out.println();

					++idx;

				} catch( NoSuchElementException e ) {
					return;
				}
			}
		} catch( IOException e ) {
			return;
		}

		vdepth = hdepth = 1;
		for( int i=0; i<vlines.length; ++i ) {
			if( vdepth < vlines[i].length )
				vdepth = vlines[i].length;
		}
		for( int i=0; i<hlines.length; ++i ) {
			if( hdepth < hlines[i].length )
				hdepth = hlines[i].length;
		}

		valid = true;
	}
}

//================================================================================
//	ののぐらむ（アプリケーション・フレーム）
//================================================================================
class Nonogram extends Frame {
	NonogramApplet	applet;		// アプレット
	Dimension  app_size;		// フレームのサイズ
	int	bdwidth  = 20;		// 盤の幅
	int	bdheight = 20;		//     高さ

	boolean	checkeddata = false;	// チェック済み作成データ

	Panel	fullPanel;

	String	      currentMode;	// 現在の表示モード
	Panel	      centerPanel;	// カードレイアウトのためのセンターパネル
	CheatPanel    cheatPanel;	// 問題入力パネル
	Answer	      answer;		// 解答
	MakePanel     makePanel;	// 問題作成パネル
	PlayPanel     playPanel;	// 遊びパネル

	SizeFrame    sizeFrame;		// サイズ・ダイアログ

	Label	copyright;
	int	unit	 = 18;
	int	gap	 = 10;
	Font	btnfont = new Font( "Helvetica", 0, 18 );

	//----------------------------------------
	//	構築子
	//----------------------------------------
	Nonogram( NonogramApplet a ) {
		applet = a;
		setTitle( "Nonogram" );

		resize( 610, 710 );

		setupMenuBar();

		fullPanel = new Panel();
		add( "Center", fullPanel );
		fullPanel.setLayout(new BorderLayout());

		centerPanel = new Panel();
		centerPanel.setLayout( new CardLayout() );
		fullPanel.add( "Center", centerPanel );

		currentMode = "Cheat";

		cheatPanel = new CheatPanel( this );
		centerPanel.add( "Cheat",  cheatPanel );

		answer = new Answer( this );

		makePanel = new MakePanel( this );
		centerPanel.add( "Make", makePanel );

		playPanel = new PlayPanel( this );
		centerPanel.add( "Play", playPanel );

		sizeFrame = new SizeFrame( this );

		// (C)1996 ...
		Label  copyright = new Label("Nonogram V0.5" + "  " + 
						"Copyright(C)1996 Hirofumi Fujiwara.",
					Label.CENTER );
		fullPanel.add( "South", copyright );
	}

	//----------------------------------------
	//	パネルの作成
	//----------------------------------------
	void makePanels() {
		cheatPanel.make();
		playPanel.make();
	}

	//----------------------------------------
	//	メニューバーの作成
	//----------------------------------------
	private void setupMenuBar() {
		Font	font = new Font( "Helvetica", Font.BOLD, 14 );

		Menu	  menu;
		MenuItem  item;
		MenuBar mbar = new MenuBar();

		menu = new Menu( "File" );
		menu.setFont( font );
		menu.add( item = new MenuItem( "Clear" ) );
		item.setFont( font );
		menu.add( item = new MenuItem( "Post" ) );
		item.setFont( font );
		menu.add( item = new MenuItem( "Quit" ) );
		item.setFont( font );
		mbar.add(menu);

		menu = new Menu( "Mode" );
		menu.setFont( font );
		menu.add( item = new MenuItem( "Cheat" ) );
		item.setFont( font );
		menu.add( item = new MenuItem( "Make" ) );
		item.setFont( font );
		menu.add( item = new MenuItem( "Play" ) );
		item.setFont( font );
		mbar.add(menu);

		menu = new Menu( "Edit" );
		menu.setFont( font );
		menu.add( item = new MenuItem( "Size" ) );
		item.setFont( font );
		mbar.add(menu);

		menu = new Menu( "Solve" );
		menu.setFont( font );
		menu.add( item = new MenuItem( "Check" ) );
		item.setFont( font );
		mbar.add(menu);

		setMenuBar(mbar);
	}

	//----------------------------------------
	//	パネルの表示
	//	showforced( name )
	//		表示パネルを指定
	//		"Cheat" | "Make" | "Play"
	//----------------------------------------
	void showforced( String name ) {
		((CardLayout)centerPanel.getLayout()).show( centerPanel, name );
		currentMode = name;

		if( name.equals( "Play" ) ) {
			playPanel.resizeWindow();
		}
	}

	//----------------------------------------
	//	アクション処理
	//----------------------------------------
	public boolean action( Event e, Object o ) {
		if( e.target instanceof MenuItem ) {
			if( o.equals("Clear") ) {
				if( currentMode.equals( "Cheat" ) ) {
					cheatPanel.clear();

				} else if( currentMode.equals( "Make" ) ) {
					makePanel.chkcount = 0;
					makePanel.clearTable();

				} else if( currentMode.equals( "Play" ) ) {
					playPanel.clear();
				}
				return	true;
			}
			if( o.equals("Quit") ) {
				sizeFrame.hide();
				hide();
				return	true;
			}
			if( o.equals("Post") ) {
				if( ! checkeddata ) {
					// データが検査済みでない。
					System.err.println( "not checked" );
					return	true;
				}
				if( ! answer.post( makePanel.makesolvedata() ) ) {
					// エラー発生
					return	true;
				}
				sizeFrame.hide();
				hide();
				URL url;
				try {
					url = new URL( "http://www.pro.or.jp/~fuji/nonogram/post.html" );
				} catch( MalformedURLException ex ) {
					return	true;
				}
				applet.getAppletContext().showDocument( url );
				return	true;
			}

			if( o.equals("Cheat") ) {
				showforced( "Cheat" );
				cheatPanel.resizeWindow();
				return	true;
			}
			if( o.equals("Make") ) {
				showforced( "Make" );
				return	true;
			}
			if( o.equals("Play") ) {
				showforced( "Play" );
				return	true;
			}
			if( o.equals("Size") ) {
				sizeFrame.popup();
				return	true;
			}
			if( o.equals("Check") ) {
				if( currentMode.equals( "Cheat" ) ) {
					cheatPanel.solve();

				} else if( currentMode.equals( "Make" ) ) {
					makePanel.check();

				} else if( currentMode.equals( "Play" ) ) {
					playPanel.check();
				}
				return	true;
			}
		}

		if( e.target instanceof TextField ) {
			if( e.target.equals( cheatPanel.linedata.text ) ) {
				cheatPanel.linedata.setData();
				return	true;
			}
		}

		return	false;
	}
}

//================================================================================
//	サイズ・ダイアログ
//================================================================================
class  SizeFrame extends Frame {
	Nonogram	app;
	Panel		centerPanel, sizePanel;
	TextField	widthfield, heightfield, wdepthfield, hdepthfield;
	TextField	punitfield;

	SizeFrame( Nonogram parent ) {
		app = parent;
		setTitle( "Nonogram : Size" );
		setFont( new Font( "Helvetica", Font.BOLD, 16 ) );
		setLayout( new BorderLayout( 20, 20 ) );

		centerPanel = new Panel();
		add( "Center", centerPanel );

		makeSize();

		Panel	btns;
		btns = new Panel();
		btns.setLayout(new GridLayout(1,2,20,10));
		btns.add( new Button( "OK" ) );
		btns.add( new Button( "Cancel" ) );

		add( "South", btns );

		pack();
	}

	void makeSize() {
		Label      lab;
		TextField  txf;
		Panel	   p;

		sizePanel = new Panel();
		centerPanel.add( sizePanel );
		sizePanel.setLayout( new GridLayout(3,2,20,10));

		sizePanel.add( lab = new Label( "width:", Label.RIGHT ) );
		sizePanel.add( widthfield = new TextField( "", 4 ) );

		sizePanel.add( lab = new Label( "height:", Label.RIGHT ) );
		sizePanel.add( heightfield = new TextField( "", 4 ) );

		sizePanel.add( lab = new Label( "unit:", Label.RIGHT ) );
		sizePanel.add( punitfield = new TextField( "", 4 ) );
	}

	void boardresize() {
		boolean	boardchanged = false;
		boolean	cellsizechanged = false;

		int wd = getValue( widthfield,  200 );
		int ht = getValue( heightfield, 200 );
		if( wd != app.bdwidth ) {
			app.bdwidth = wd;  boardchanged = true;
		}
		if( ht != app.bdheight ) {
			app.bdheight = ht;  boardchanged = true;
		}

		int un     = getValue( punitfield, 40 );
		if( un != app.unit ) {
			app.playPanel.unit = app.cheatPanel.unit = app.unit = un; 
			cellsizechanged = true;
		}

		Dimension sz = app.size();
		app.resize( sz );

		if( boardchanged ) {
			app.cheatPanel.resize();
		}
		app.cheatPanel.resizeWindow();

		if( boardchanged ) {
			app.playPanel.resize();
		}
		app.playPanel.resizeWindow();

		if( boardchanged ) {
			app.makePanel.resize();
			app.answer.resize();
		}
	}	

	void popup() {
		setupValue();
		show();
	}

	void setupValue() {
		widthfield.setText( String.valueOf(app.bdwidth) );
		heightfield.setText( String.valueOf(app.bdheight) );
		punitfield.setText( String.valueOf(app.unit) );
	}

	int getValue( TextField tf, int maxval ) {
		int	i;
		try {
			i = Integer.parseInt( tf.getText() );
		} catch( RuntimeException e ) {
			i = 0;
		}
		if( i<=0 )
			i = 1;
		if( i>maxval )
			i = maxval;
		tf.setText( String.valueOf( i ) );
		return	i;
	}
	
	public boolean action( Event e, Object o ) {
		if( e.target instanceof Button ) {	// テキストフィールド
			if( "OK".equals( o ) ) {
				boardresize();
				return	true;
			}
			if( "Cancel".equals( o ) ) {
				hide();
				return	true;
			}
		}
		return	true;
	}
}

//================================================================================
//	共通パネル（ヒントテーブルつき）
//================================================================================
abstract class  CommonPanel extends Panel {
	Nonogram	app;
				// パネルのサイズ（このサイズに追随させる）
	Dimension	size = new Dimension(0,0);

	HintTable	vHint, hHint;	// 垂直（上）、水平（左）ヒントテーブル
	int		uvw,  uvh;	// 見える範囲
	int		unit;
	int		gap = 3;
	int		vdepth  = 5;	//     深さ
	int		hdepth  = 5;	//     深さ

	abstract void paint();
	abstract void resizeWindow();

	void makeHints( boolean pl ) {
		vHint = new HintTable( app, this, size, 'v', pl );
		hHint = new HintTable( app, this, size, 'h', pl );
	}

	void findviewunit() {
		int	n;
		int	unit = app.unit;

		n = (size().width - hdepth*unit - gap*2 - 40)/unit;
		if( n > app.bdwidth )
			n = app.bdwidth;
		else {
			n = (n / 5) * 5;
			if( n < 5 )
				n = 5;
		}
		uvw = n;

		n = (size().height - vdepth*unit - gap*2 - 40)/unit;
		if( n > app.bdheight )
			n = app.bdheight;
		else {
			n = (n / 5) * 5;
			if( n < 5 )
				n = 5;
		}
		uvh = n;
	}

	void findpreviewunit() {
		int	n;
		int	unit = app.unit;

		n = (app.size().width - hdepth*unit - gap*2 - 40 - 20)/unit;
		if( n > app.bdwidth )
			n = app.bdwidth;
		else {
			n = (n / 5) * 5;
			if( n < 5 )
				n = 5;
		}
		uvw = n;

		n = (app.size().height - vdepth*unit - gap*2 - 40 - 100 )/unit;
		if( n > app.bdheight )
			n = app.bdheight;
		else {
			n = (n / 5) * 5;
			if( n < 5 )
				n = 5;
		}
		uvh = n;
	}
}

//================================================================================
//	遊びキャンバス
//================================================================================
class  PlayCanvas extends Canvas {
	PlayPanel     panel;	// 親パネル
	Image	fullCanvas;
	Graphics  fg;
	int	uvw, uvh;	// 枠単位単位でのビューサイズ
	int	ufw, ufh;	// 枠単位単位でのフルサイズ
	int	vw, vh;		// ドット単位でのビューサイズ
	int	fw, fh;		// ドット単位でのフルサイズ
	Font	font;

	boolean		dragging;
	boolean		dragh, dragv;		// h方向、v方向のドラッグ
	int		dragvalue;
	int		previx, previy;		// 直前のマウス位置

	//----------------------------- PlayCanvas
	//	構築子 
	//----------------------------------------
	PlayCanvas( PlayPanel p ) {
		panel = p;
		resize();
	}

	//----------------------------- PlayCanvas
	//	サイズ変更 
	//----------------------------------------
	void resize() {
		int	unit = panel.unit;

		fw = (ufw=panel.vHint.ufw) * unit + 1;
		fh = (ufh=panel.hHint.ufh) * unit + 1;
		fullCanvas = null;
		fg = null;
		dragging = false;
	}

	//----------------------------- PlayCanvas
	//	ウィンドウのサイズが変更された
	//----------------------------------------
	void resizeWindow() {
		int	unit = panel.unit;

		vw = (uvw=panel.vHint.uvw) * unit + 1;
		vh = (uvh=panel.hHint.uvh) * unit + 1;
		resize( vw, vh );
		resize();
	}

	//----------------------------- PlayCanvas
	//	移動した
	//----------------------------------------
	void moved() {
		paint();		
	}

	//----------------------------- PlayCanvas
	//	フルサイズ画面の描画
	//----------------------------------------
	void paintFull() {
		int	i, j;
		int	unit = panel.unit;

		fg.setColor( Color.white );
		fg.fillRect( 0, 0, fw, fh );

		for( i=0; i<=ufw; ++i ) {
			fg.setColor( (i%5==0) ? Color.darkGray : Color.lightGray );
			fg.drawLine( unit*i, 0, unit*i, unit*ufh );
		}
		for( i=0; i<=ufh; ++i ) {
			fg.setColor( (i%5==0) ? Color.darkGray : Color.lightGray );
			fg.drawLine( 0, unit*i, unit*ufw, unit*i );
		}

		for( i=0; i<ufw; ++i ) {
			for( j=0; j<ufh; ++j ) {
				paint( i, j );
			}
		}
	}

	//----------------------------- PlayCanvas
	//	描画
	//		描画は、フルサイズ画面の内容を移すだけである。
	//----------------------------------------
	public void show() {
		paint();
	}

	void paint() {
		paint( getGraphics() );
	}

	void paintError( char d, int ln ) {
		int	x0, y0, x1, y1;
		int	unit = panel.unit;

		if( d == 'v' ) {
			x0 = x1 = ln;
			y0 = 0;
			y1 = ufh-1;
		} else {
			y0 = y1 = ln;
			x0 = 0;
			x1 = ufw-1;
		}
		x0 = x0*unit + unit/2;
		x1 = x1*unit + unit/2;
		y0 = y0*unit + unit/2;
		y1 = y1*unit + unit/2;
		fg.setColor( Color.red );
		fg.drawLine( x0, y0, x1, y1 );
	}

	public void paint( Graphics g ) {
		if( fg == null ) {
			fullCanvas = panel.createImage( fw, fh );
			fg = fullCanvas.getGraphics();
			paintFull();
		}

		int	unit = panel.unit;
		g.drawImage( fullCanvas, 
			-panel.vHint.hval*unit, -panel.hHint.vval*unit, this );
	}

	//----------------------------- PlayCanvas
	// 	表示（１ピクセル分）
	//
	//	v = 0	□
	//	v = 1	■
	//	v = -1	・
	//	ヒント色：Color.orange
	//----------------------------------------
	public void	paint( int x, int y ) {
		Color   hintcolor = Color.orange;

		if( panel.table == null )
			return;

		int	u = panel.unit;
		int	xs = x*u;
		int	ys = y*u;

		int	v = panel.table[x][y];
		boolean h = panel.hinttable[x][y];

		if( v==0 ) {
			fg.setColor( Color.white );
			fg.fillRect( xs, ys, u, u );
		} else if( v==1 ) {
			Color c = h ? hintcolor : Color.black;
			fg.setColor( c );
			fg.fillRect( xs, ys, u, u );
		} else if( v == -1 ) {
			fg.setColor( Color.white );
			fg.fillRect( xs, ys, u, u );
			int	e = (u-1)/4;
			int	d = (u-e-1)/2;
			e = u - 1 - d*2;
			Color c = h ? hintcolor : Color.black;
			fg.setColor( c );
			fg.fillRect( xs+d+1, ys+d+1, e, e );
		}

		// 枠の描画
		fg.setColor( (y%5==0) ? Color.darkGray : Color.lightGray  );
		fg.drawLine( xs, ys, xs+u, ys );
		fg.setColor( ((y+1)%5==0) ? Color.darkGray : Color.lightGray  );
		fg.drawLine( xs, ys+u, xs+u, ys+u );
		fg.setColor( (x%5==0) ? Color.darkGray : Color.lightGray  );
		fg.drawLine( xs, ys, xs, ys+u );
		fg.setColor( ((x+1)%5==0) ? Color.darkGray : Color.lightGray  );
		fg.drawLine( xs+u, ys, xs+u, ys+u );
	}

	//----------------------------- PlayCanvas
	// 	マウスの押し下げ
	//----------------------------------------
	public boolean mouseDown( Event evt, int x, int y ) {
		int  ix = x/panel.unit + panel.vHint.hval;
		int  iy = y/panel.unit + panel.hHint.vval;
		if( ix<0 || ufw<=ix || iy<0 || ufh<=iy )
			return	true;		// 無視

		int	v = panel.table[ix][iy];
		v = (++v==2) ? -1 : v;
		panel.table[ix][iy] = v;
		panel.hinttable[ix][iy] = panel.ishintmode;

		dragging = true;
		dragh = dragv = true;	// h,v 方向、共にドラッグ可能
		dragvalue = v;
		paint( ix, iy );
		paint();
		panel.setactiveline( ix, iy );

		return	true;
	}

	//----------------------------- PlayCanvas
	// 	マウスのドラッグ
	//----------------------------------------
	public boolean mouseDrag( Event evt, int x, int y ) {
		if( ! dragging )
			return true;
		int  ix = x/panel.unit + panel.vHint.hval;
		int  iy = y/panel.unit + panel.hHint.vval;

		if( ! dragh )
			ix = previx;
		if( ! dragv )
			iy = previy;

		if( ix<0 || ufw<=ix || iy<0 || ufh<=iy )
			return	true;		// 無視

		if( ix == previx && iy == previy )
			return	true;

		if( ix == previx )
			dragh = false;
		if( iy == previy )
			dragv = false;

		panel.table[ix][iy] = dragvalue;
		panel.hinttable[ix][iy] = panel.ishintmode;
		paint( ix, iy );
		paint();
		panel.setactiveline( ix, iy );

		previx = ix;
		previy = iy;  

		return	true;
	}

	//----------------------------- PlayCanvas
	// 	マウスがＵＰ
	//----------------------------------------
	public boolean mouseUp( Event evt, int x, int y ) {
		dragging = false;
		return	true;
	}

	//----------------------------- PlayCanvas
	// 	マウスの移動
	//----------------------------------------
	public boolean mouseMove( Event evt, int x, int y ) {
		int  ix = x/panel.unit + panel.vHint.hval;
		int  iy = y/panel.unit + panel.hHint.vval;

		if( ix<0 || ufw<=ix || iy<0 || ufh<=iy )
			return	true;		// 無視
		panel.setactiveline( ix, iy );

		return	true;
	}
}

//================================================================================
//	遊び用パネル
//================================================================================
class  PlayPanel extends CommonPanel {
	GridBagLayout		gbl;
	GridBagConstraints	gbc;
	PlayCanvas		canvas;
	Panel			controlPanel;
	Checkbox		hintbox;	// ヒント
	boolean			ishintmode;

	Scrollbar	hbar, vbar;
	int		hmax, vmax;	// スクロールバー最大位置
	int		hval, vval;	// スクロールバー位置
	int		table[][];	// -1:・0:□ 1:■ 
	boolean		hinttable[][];
	Font	boldfont = new Font( "Helvetica", Font.BOLD, 14 );

	//------------------------------ PlayPanel
	//	構築子
	//----------------------------------------
	PlayPanel( Nonogram a ) {
		app = a;

		unit  = app.unit;

		gbl = new GridBagLayout();
		gbc = new GridBagConstraints();
		setLayout( gbl );
	}

	//------------------------------ PlayPanel
	//	テーブル類の生成
	//----------------------------------------
	void make() {
		if( app.applet.problem.valid ) {
			app.applet.problem.resize( app );
		}

		findpreviewunit();

		// ヒントテーブルの作成
		makeHints( true );

		hbar = vHint.hbar;
		vbar = hHint.vbar;
		hmax = vHint.hmax;
		vmax = hHint.vmax;
		hval = vHint.hval;
		vval = hHint.vval;

		cleartable();
		canvas = new PlayCanvas( this );

		controlPanel = new Panel();
		controlPanel.setLayout( new BorderLayout() );
		hintbox = new Checkbox( "Hint" );
		hintbox.setFont( boldfont );
		controlPanel.add( "South", hintbox );

		hHint.activeline = 0;
		vHint.activeline = 0;

		// レイアウトの設定
		gbl.columnWidths = new int[5];
		gbl.rowHeights   = new int[5];
		gbl.columnWidths[1] = gbl.columnWidths[3] = gap; 
		gbl.rowHeights[1]   = gbl.rowHeights[3]   = gap;
		gbc.gridwidth = gbc.gridheight = 1;

		// 制御盤（左上隅）
		gbc.gridx = 0;
		gbc.gridy = 0;
		gbc.fill = GridBagConstraints.BOTH;
		gbl.setConstraints( controlPanel, gbc );
		add( controlPanel );

		// 書き込み盤面
		gbc.gridx = 2;
		gbc.gridy = 2;
		gbc.fill = GridBagConstraints.BOTH;
		gbl.setConstraints( canvas, gbc );
		add( canvas );

		// 垂直（上）ヒントテーブル
		gbc.gridx = 2;
		gbc.gridy = 0;
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.SOUTH;
		gbl.setConstraints( vHint.hinttable, gbc );
		add( vHint.hinttable );

		// 水平スクロールバー
		gbc.gridx = 2;
		gbc.gridy = 4;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbc.anchor = GridBagConstraints.CENTER;
		gbl.setConstraints( vHint.hbar, gbc );
		// add( vHint.hbar );
		vHint.hadd = false;

		// 水平（左）ヒントテーブル
		gbc.gridx = 0;
		gbc.gridy = 2;
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.EAST;
		gbl.setConstraints( hHint.hinttable, gbc );
		add( hHint.hinttable );

		// 垂直スクロールバー
		gbc.gridx = 4;
		gbc.gridy = 2;
		gbc.fill = GridBagConstraints.VERTICAL;
		gbc.anchor = GridBagConstraints.CENTER;
		gbl.setConstraints( hHint.vbar, gbc );
		// add( hHint.vbar );
		hHint.vadd = false;
	}

	//------------------------------ PlayPanel
	//	チェック結果をカラーで表示
	//	0 Normal, 1: OK(green), -1:Error(red)
	//----------------------------------------
	void  showError( int stat ) {
		Color  col;
		if( stat == 0 ) {
			col = getBackground();
		} else {
			col = stat < 0 ? Color.red : Color.green;
		}
		controlPanel.setBackground( col );
	}

	//------------------------------ PlayPanel
	//	テーブルサイズの変更
	//----------------------------------------
	void  resize() {
		vHint.resize();
		hHint.resize();
		hmax = vHint.hmax;
		vmax = hHint.vmax;
		hval = vHint.hval;
		vval = hHint.vval;

		cleartable();
		canvas.resize();
		setactiveline( 0, 0 );

		validate();
	}

	//------------------------------ PlayPanel
	//	ウィンドウのサイズが変更された
	//----------------------------------------
	void resizeWindow() {
		findviewunit();
		hHint.resizeWindow();
		vHint.resizeWindow();
		canvas.resizeWindow();

		validate();
	}

	//------------------------------ PlayPanel
	//	クリア（再プレイ）
	//----------------------------------------
	void clear() {
		vHint.clearMarked();
		vHint.hinttable.paintAll();
		hHint.clearMarked();
		hHint.hinttable.paintAll();

		cleartable();
		canvas.paintFull();
		paint();
	}

	//------------------------------ PlayPanel
	//	テーブルサイズのクリア
	//----------------------------------------
	void cleartable() {
		table = new int[app.bdwidth][app.bdheight];
		hinttable = new boolean[app.bdwidth][app.bdheight];

//		for( int i=0; i<app.bdwidth; ++i ) {
//			for( int j=0; j<app.bdheight; ++j ) {
//				table[i][j] = 0;
//				hinttable[i][j] = false;
//			}
//		}
	}

	//------------------------------ PlayPanel
	//	アクティブ行の設定
	//----------------------------------------
	void  setactiveline( int x, int y ) {
		if( 0<=x && x<app.bdwidth && x!=vHint.activeline ) {
			vHint.activeline = x;
			vHint.paint();
		}
		if( 0<=y && y<app.bdheight && y!=hHint.activeline ) {
			hHint.activeline = y;
			hHint.paint();
		}
	}

	//------------------------------ PlayPanel
	//	問題のロード
	//----------------------------------------
	void setprob( Problem problem ) {

		if( ! problem.valid )
			return;

		for( int x=0; x<app.bdwidth; ++x ) {
			int  len = problem.vlines[x].length;
			app.playPanel.vHint.setValues( x, len, problem.vlines[x] );
		}
		for( int y=0; y<app.bdheight; ++y ) {
			int  len = problem.hlines[y].length;
			app.playPanel.hHint.setValues( y, len, problem.hlines[y] );
		}
	}

	//------------------------------ PlayPanel
	//	チェック
	//----------------------------------------
	void	check() {
		int	vals[] = new int[100];
		int	nvals;
		boolean	error = false;

		canvas.paintFull();

		// 垂直方向のチェック
		for( int i=0; i<app.bdwidth; ++i ) {
			boolean	verror = false;
			int	len = 0;
			nvals = 0;
			for( int j=0; j<app.bdheight; ++j ) {
				int	v = table[i][j];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					vals[nvals++] = len;
					len = 0;
				}
			}
			if( len > 0 ) {
				vals[nvals++] = len;
			}

			if( vHint.hints[i].length != nvals )
				verror = true;
			else {
				for( int k=0; k<nvals; ++k ) {
					if( vals[k] != vHint.hints[i][k] )
						verror = true;
				}
			}
			if( verror ) {
				canvas.paintError( 'v', i );
				error = true;
			}
		}

		for( int i=0; i<app.bdheight; ++i ) {
			boolean	herror = false;
			int	len = 0;
			nvals = 0;
			for( int j=0; j<app.bdwidth; ++j ) {
				int	v = table[j][i];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					vals[nvals++] = len;
					len = 0;
				}
			}
			if( len > 0 ) {
				vals[nvals++] = len;
			}

			if( hHint.hints[i].length != nvals )
				herror = true;
			else {
				for( int k=0; k<nvals; ++k ) {
					if( vals[k] != hHint.hints[i][k] )
						herror = true;
				}
			}
			if( herror ) {
				canvas.paintError( 'h', i );
				error = true;
			}
		}

		showError( error ? -1 : 1 );
		paint();
	}

	//------------------------------ PlayPanel
	//	ボタンが押された時の処理
	//----------------------------------------
	public boolean action( Event evt, Object obj ) {
		if( evt.target == hintbox ) {
			ishintmode = hintbox.getState();
			return true;
		}
		return true;
	}

	//------------------------------ PlayPanel
	//	スクロールバーのイベント処理
	//----------------------------------------
	public boolean handleEvent( Event e ) {
		if( e.target instanceof Scrollbar ) {	// スクロールバーが押された
			if( e.target == vHint.vbar || e.target == vHint.hbar ) {
				vHint.moved();
			}
			if( e.target == hHint.vbar || e.target == hHint.hbar ) {
				hHint.moved();
			}
			if( e.target == vHint.hbar || e.target == hHint.vbar ) {
				hmax = vHint.hmax;
				vmax = hHint.vmax;
				hval = vHint.hval;
				vval = hHint.vval;
				canvas.moved();
			}
			return	true;
		}
		return	super.handleEvent(e);
	}

	//------------------------------ PlayPanel
	//	描画
	//----------------------------------------
	void  paint() {
		vHint.paint();
		hHint.paint();
		canvas.paint();
	}

	public void  paint( Graphics g ) {
		showError( 0 );

		Dimension sz = size();
		if( ! (sz.width==size.width && sz.height==size.height) ) {
			// パネルのサイズが変更された。
			size = sz;
			resizeWindow();
		}

		paint();
	}

	public void  showpanel() {
		resizeWindow();
		size = size();
		paint();
	}
}

//================================================================================
//	解答盗み見用パネル
//================================================================================
class  CheatPanel extends CommonPanel {
	GridBagLayout		gbl;
	GridBagConstraints	gbc;
	LineData		linedata;	// 行入力処理（パネル）

	//----------------------------- CheatPanel
	//	構築子
	//----------------------------------------
	CheatPanel( Nonogram a ) {
		app = a;
		unit = app.unit;
		uvw = uvh = 20;

		gbl = new GridBagLayout();
		gbc = new GridBagConstraints();
		setLayout( gbl );
	}

	//----------------------------- CheatPanel
	//	ヒントテーブルの生成
	//----------------------------------------
	void make() {
		makeHints( false );				// ヒントテーブルの作成
		
		linedata = new LineData( app, this );		// １行データ入力用

		gbl.columnWidths = new int[7];
		gbl.rowHeights   = new int[7];
		gbl.columnWidths[1] = gbl.columnWidths[3] = gbl.columnWidths[5] = gap; 
		gbl.rowHeights[1]   = gbl.rowHeights[3]   = gbl.rowHeights[5]   = gap;
		gbc.gridwidth = gbc.gridheight = 1;

		// 垂直（上）ヒントテーブル
		gbc.gridx = 4;
		gbc.gridy = 2;
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.SOUTHWEST;
		gbl.setConstraints( vHint.hinttable, gbc );
		add( vHint.hinttable );

		// 水平スクロールバー
		gbc.gridx = 4;
		gbc.gridy = 0;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbc.anchor = GridBagConstraints.CENTER;
		gbl.setConstraints( vHint.hbar, gbc );
		add( vHint.hbar );
		vHint.hadd = true;

		// 水平（左）ヒントテーブル
		gbc.gridx = 2;
		gbc.gridy = 4;
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.NORTHEAST;
		gbl.setConstraints( hHint.hinttable, gbc );
		add( hHint.hinttable );

		// 垂直スクロールバー
		gbc.gridx = 0;
		gbc.gridy = 4;
		gbc.fill = GridBagConstraints.VERTICAL;
		gbc.anchor = GridBagConstraints.CENTER;
		gbl.setConstraints( hHint.vbar, gbc );
		add( hHint.vbar );
		hHint.vadd = true;

		// １行入力エリア
		gbc.gridx = 4;
		gbc.gridy = 4;
		gbc.gridwidth = 3;
		gbc.fill = GridBagConstraints.BOTH;
		gbl.setConstraints( linedata, gbc );
		add( linedata );
	}

	//----------------------------- CheatPanel
	//	クリア
	//----------------------------------------
	public  void  clear() {
		vdepth  = 5;
		hdepth  = 5;
		resize();
	}

	//----------------------------- CheatPanel
	//	テーブルサイズの変更
	//----------------------------------------
	public  void  resize() {
		vHint.resize();
		hHint.resize();

		linedata.clear();

		validate();
	}

	//----------------------------- CheatPanel
	//	ウィンドウのサイズが変更された
	//----------------------------------------
	void resizeWindow() {
		findviewunit();
		hHint.resizeWindow();
		vHint.resizeWindow();

		validate();
	}

	//----------------------------------------
	//	アクティブ行のインクリメント
	//----------------------------------------
	void incactive() {
		if( vHint.activeline >= 0 ) {
			if( ++vHint.activeline >= app.bdwidth ) {
				vHint.activeline = -1;
				hHint.activeline = 0;
			}
		} else if( hHint.activeline >= 0 ) {
			if( ++hHint.activeline >= app.bdheight ) {
				hHint.activeline = -1;
				vHint.activeline = 0;
			}
		}
	}
	
	//----------------------------- CheatPanel
	//	アクティブ行を文字データとして返す
	//----------------------------------------
	String getLine() {
		String	str = "";
		
		if( vHint.activeline >= 0 ) {
			int x = vHint.activeline;
			for( int i=0; i<vHint.hints[x].length; ++i ) {
				int  v = vHint.hints[x][i];
				if( v > 0 )
					str += " "+v;
			}
		} else if( hHint.activeline >= 0 ) {
			int y = hHint.activeline;
			for( int i=0; i<hHint.hints[y].length; ++i ) {
				int  v = hHint.hints[y][i];
				if( v > 0 )
					str += " "+v;
			}
		}

		return	str;
	}

	//----------------------------- CheatPanel
	//	送信データを作成する
	//----------------------------------------
	String	makesolvedata() {
		String SendData = "";
		SendData += "size " + app.bdwidth + " " + app.bdheight + "\n";

		// depth の部分は、将来不要になる筈。
		int vd = 1;
		for( int i=0; i<app.bdwidth; ++i ) {
			if( vd < vHint.hints[i].length )
				vd = vHint.hints[i].length;
		}
		int hd = 1;
		for( int i=0; i<app.bdheight; ++i ) {
			if( hd < hHint.hints[i].length )
				hd = hHint.hints[i].length;
		}
		SendData += "depth " + vd + " " + hd + "\n";

		for( int i=0; i<app.bdwidth; ++i ) {
			String str = "";
			for( int j=0; j<vHint.hints[i].length; ++j ) {
				int	v = vHint.hints[i][j];
				if( str.length() != 0 )
					str += " ";
				str += v;
			}
			if( str.length() == 0 )
				str = "-";
			SendData += str + "\n";
		}

		for( int i=0; i<app.bdheight; ++i ) {
			String str = "";
			for( int j=0; j<hHint.hints[i].length; ++j ) {
				int	v = hHint.hints[i][j];
				if( str.length() != 0 )
					str += " ";
				str += v;
			}
			if( str.length() == 0 )
				str = "-";
			SendData += str + "\n";
		}

		SendData += "end\n";

		return	SendData;
	}

	//----------------------------- CheatPanel
	//	解く
	//----------------------------------------
	void solve() {
		if( app.answer.solve( makesolvedata() ) ) {
			app.makePanel.copyfirstanswer();
			app.makePanel.chkcount = app.answer.anscount;
			app.makePanel.paint();
			app.showforced( "Make" );
		}
	}

	//----------------------------- CheatPanel
	//	ボタンが押された時の処理
	//----------------------------------------
	public boolean action( Event evt, Object obj ) {
		if( "Clear".equals(obj) ) {
			linedata.clear();
			return true;
		}
		return false;
	}

	//----------------------------- CheatPanel
	//	スクロールバーのイベント処理
	//----------------------------------------
	public boolean handleEvent( Event e ) {
		if( e.target instanceof Scrollbar ) {	// スクロールバーが押された
			if( e.target == vHint.vbar || e.target == vHint.hbar ) {
				vHint.moved();
			}
			if( e.target == hHint.vbar || e.target == hHint.hbar ) {
				hHint.moved();
			}
			return	true;
		}
		return	super.handleEvent(e);
	}

	//----------------------------- CheatPanel
	//	描画
	//----------------------------------------
	void  paint() {
		vHint.paint();
		hHint.paint();
	}

	public void  paint( Graphics g ) {
		Dimension sz = size();
		if( ! (sz.width==size.width && sz.height==size.height) ) {
			// パネルのサイズが変更された。
			size = sz;
			resizeWindow();
		}
		paint();
	}
}

//================================================================================
//	作成キャンバス
//================================================================================
class  MakeCanvas extends Canvas {
	Nonogram	app;
	MakePanel	makepanel;
	int		unit;
	Dimension	panelsize = new Dimension(0,0);

	Image		offImage;
	Graphics	og;
	int		offwidth;
	int		offheight;
	int		offunit;

	boolean		dragging;
	int		dragvalue;
	int		previx, previy;		// 直前のマウス位置

	//----------------------------------------
	// 	構築子
	//----------------------------------------
	MakeCanvas( Nonogram a, MakePanel panel ) {
		app = a;
		makepanel = panel;
		dragging = false;
		resize( 1, 1 );			// ダミー
	}

	//----------------------------------------
	// 	サイズ調整
	//----------------------------------------
	void resizing() {
		// 表示の切替え
		Dimension	sz = makepanel.centerPanel.size();
		boolean		changed = false;

		// パネルサイズが変っていた。
		if( sz.width!=panelsize.width || sz.height!=panelsize.height ||
                    offwidth!=app.bdwidth || offheight!=app.bdheight ) {
			panelsize = sz;
			offwidth  = app.bdwidth;
			offheight = app.bdheight;

			int	w = (sz.width-app.gap*2)/app.bdwidth;
			int	h = (sz.height-app.gap*2)/app.bdheight;

			unit = w<h ? w : h;
			if( unit > 30 )
				unit = 30;
			if( unit < 3 )
				unit = 3;
			changed = true;
		}

		if( changed || offunit!=unit ) {
			offunit   = unit;
			int	cw = offwidth *unit+1;
			int	ch = offheight*unit+1;
			resize( cw, ch );

			makepanel.validate();

			offImage = app.applet.createImage( cw, ch );
			og = offImage.getGraphics();
			og.clearRect( 0, 0, cw, ch );
		}
	}

	//----------------------------------------
	// 	表示
	//----------------------------------------
	public void	paint( Graphics  g ) {

		resizing();		// サイズ調整

		for( int x=0; x<app.bdwidth; ++x ) {
			for( int y=0; y<app.bdheight; ++y ) {
				paint( og, x, y );
			}
		}

		if( makepanel.chkcount > 1 ) {
			boolean	marked = false;
			for( int i=0; i<2 && !marked ; ++i ) {
				for( int x=0; x<app.bdwidth; ++x ) {
					for( int y=0; y<app.bdheight; ++y ) {
						if( makepanel.table[x][y] == app.answer.table[i][x][y] )
							continue;
						paintError( og, x, y );
						marked = true;
					}
				}
			}
		}

		g.drawImage( offImage, 0, 0, this );
	}

	//----------------------------------------
	// 	表示（１ピクセル分）
	//----------------------------------------
	public void	paint( Graphics  g, int x, int y ) {
		Color	cols[] = new Color[2];
		cols[0] = Color.white;
		cols[1] = Color.black;
		int	xs = x*unit;
		int	ys = y*unit;
		g.fillRect( xs, ys, unit, unit );

		int	v = makepanel.table[x][y];
		g.setColor( cols[v] );
		g.fillRect( xs, ys, unit, unit );

		g.setColor( (y%5==0) ? Color.darkGray : Color.lightGray  );
		g.drawLine( xs, ys, xs+unit, ys );
		g.setColor( ((y+1)%5==0) ? Color.darkGray : Color.lightGray  );
		g.drawLine( xs, ys+unit, xs+unit, ys+unit );
		g.setColor( (x%5==0) ? Color.darkGray : Color.lightGray  );
		g.drawLine( xs, ys, xs, ys+unit );
		g.setColor( ((x+1)%5==0) ? Color.darkGray : Color.lightGray  );
		g.drawLine( xs+unit, ys, xs+unit, ys+unit );
	}

	public void	paintError( Graphics  g, int x, int y ) {
		int	e = unit / 3;
		int	f = unit - e * 2;
		g.setColor( Color.red );
		g.fillRect( x*unit+e, y*unit+e, f, f );
	}

	//----------------------------------------
	// 	マウスの押し下げ
	//----------------------------------------
	public boolean mouseDown( Event evt, int x, int y ) {

		app.checkeddata = false;

		int  ix = x/unit;
		int  iy = y/unit;
		if( ix < 0 || app.bdwidth <= ix || iy < 0 || app.bdheight <= iy )
			return	true;

		makepanel.chkcount = 0;
		makepanel.showError( 0 );

		makepanel.table[ix][iy] = makepanel.table[ix][iy]==0 ? 1 : 0;
		paint( getGraphics(), ix, iy );
		previx = ix;
		previy = iy;  

		dragging = true;
		dragvalue = makepanel.table[ix][iy];

		return	true;
	}

	//----------------------------------------
	// 	マウスのドラッグ
	//----------------------------------------
	public boolean mouseDrag( Event evt, int x, int y ) {
		if( ! dragging )
			return true;
		int  ix = x/unit;
		int  iy = y/unit;
		if( ix < 0 || app.bdwidth <= ix || iy < 0 || app.bdheight <= iy )
			return	true;

		if( ix == previx && iy == previy )
			return	true;

		makepanel.table[ix][iy] = dragvalue;
		paint( getGraphics(), ix, iy );

		previx = ix;
		previy = iy;  

		return	true;
	}

	//----------------------------------------
	// 	マウスが出る
	//----------------------------------------
	public boolean mouseExit( Event evt, int x, int y ) {
		dragging = false;
		return	true;
	}

	//----------------------------------------
	// 	マウスがＵＰ
	//----------------------------------------
	public boolean mouseUp( Event evt, int x, int y ) {
		dragging = false;
		return	true;
	}
}

//================================================================================
//	方向ボタンキャンバス
//================================================================================
class  DirButton extends Canvas {
	Nonogram	app;
	Image		fullcanvas;
	Graphics	fg;
	final	int	btnunit = 32;
	String		dir;
	boolean		isup;
	static final int  Lx[] = { 27, 14, 14,  3, 14, 14, 27 };
	static final int  Ly[] = { 13, 13,  5, 16, 27, 19, 19 };
	static final int  Ux[] = { 13, 13,  5, 16, 27, 19, 19 };
	static final int  Uy[] = { 27, 14, 14,  3, 14, 14, 27 };
	static final int  Dx[] = { 13, 13,  5, 16, 27, 19, 19 };
	static final int  Dy[] = {  4, 17, 17, 28, 17, 17,  4 };
	static final int  Rx[] = {  4, 17, 17, 28, 17, 17,  4 };
	static final int  Ry[] = { 13, 13,  5, 16, 27, 19, 19 };
	int		px[];
	int		py[];

	DirButton( Nonogram a, String d ) {
		app = a;
		dir = new String( d );
		isup = true;
		resize( btnunit, btnunit );
		if( d.equals("L") ) {	px = Lx; py = Ly; 	}
		if( d.equals("U") ) {	px = Ux; py = Uy;	}
		if( d.equals("D") ) {	px = Dx; py = Dy;	}
		if( d.equals("R") ) {	px = Rx; py = Ry;	}
	}

	void drawButton( Graphics g ) {
		g.setColor( Color.lightGray );
		g.fill3DRect( 0, 0, btnunit, btnunit, isup );
		g.setColor( Color.black );
		g.fillPolygon( px, py, px.length );
	}

	public void paint( Graphics g ) {
		if( fullcanvas == null ) {
			fullcanvas = app.applet.createImage( btnunit*4, btnunit );
			fg = fullcanvas.getGraphics();
		}
		drawButton( fg );
		g.drawImage( fullcanvas, 0, 0, this );
	}

	public boolean mouseDown( Event evt, int x, int y ) {
		if( isup ) {
			isup = false;
			drawButton( fg );
			paint( getGraphics() );
		}
		Event e = new Event( this, Event.ACTION_EVENT, (Object)dir );
		postEvent( e );
		return	true;
	}

	public boolean mouseUp( Event evt, int x, int y ) {
		if( ! isup ) {
			isup = true;
			drawButton( fg );
			paint( getGraphics() );
		}
		return	true;
	}

	public boolean mouseExit( Event evt, int x, int y ) {
		if( ! isup ) {
			isup = true;
			drawButton( fg );
			paint( getGraphics() );
		}
		return	true;
	}
}

//================================================================================
//	作成パネル
//================================================================================
class  MakePanel extends Panel {
	Nonogram	app;
	Panel		controls;
	Panel		centerPanel;
	MakeCanvas	canvas;

	int		table[][];	// 0 or 1 
	int		chkcount;	// 0 の時、「赤」表示しない

	//------------------------------ MakePanel
	//	構築子
	//----------------------------------------
	MakePanel( Nonogram a ) {
		app = a;

		setLayout( new BorderLayout() );

		controls = new Panel();			// 制御パネル
		controls.setLayout(new FlowLayout());
		add( "North", controls );

		ControlButton redrawBtn = new ControlButton( app, "Redraw" );
		controls.add( redrawBtn );

		controls.add( new DirButton( app, "L" ) );
		controls.add( new DirButton( app, "U" ) );
		controls.add( new DirButton( app, "D" ) );
		controls.add( new DirButton( app, "R" ) );


		centerPanel = new Panel();		// 盤面（センターパネル）
		add( "Center", centerPanel );

		GridBagLayout	gbl = new GridBagLayout();
		centerPanel.setLayout( gbl );
		GridBagConstraints c = new GridBagConstraints();
		c.gridx = 0;
		c.gridy = 0;
		c.gridwidth = c.gridheight = 1;
		c.fill = GridBagConstraints.NONE;
		c.weightx = 0.0;
		c.weighty = 0.0;
		c.anchor = GridBagConstraints.CENTER;

		canvas = new MakeCanvas( app, this );	// キャンバス
		gbl.setConstraints( canvas, c );
		centerPanel.add( canvas );

		resize();
	}

	//------------------------------ MakePanel
	//	作成テーブルのリサイズ
	//----------------------------------------
	void  resize() {
		int newtable[][] = new int[app.bdwidth][app.bdheight];
		if( table != null ) {
			int mw = app.bdwidth<table.length     ? app.bdwidth  : table.length;
			int mh = app.bdheight<table[0].length ? app.bdheight : table[0].length;
			for( int x=0; x<mw; ++x )
				for( int y=0; y<mh; ++y )
					newtable[x][y] = table[x][y];
		}
		table = newtable;
		newtable = null;

		chkcount = 0;

		validate();
		canvas.validate();

		paint();
		app.checkeddata = false;
	}

	//------------------------------ MakePanel
	//	チェック結果をカラーで表示
	//	0 Normal, 1: OK(green), -1:Error(red)
	//----------------------------------------
	void  showError( int stat ) {
		Color  col;
		if( stat == 0 ) {
			col = getBackground();
		} else {
			col = stat < 0 ? Color.red : Color.green;
		}
		controls.setBackground( col );
	}

	//------------------------------ MakePanel
	//	テーブルのクリア
	//----------------------------------------
	void  clearTable() {
		for( int x=0; x<app.bdwidth; ++x )
			for( int y=0; y<app.bdheight; ++y )
				table[x][y] = 0;
		paint();
		app.checkeddata = false;
	}

	//------------------------------ MakePanel
	//	移動
	//----------------------------------------
	void  moveLeft() {
		for( int x=0; x<app.bdwidth-1; ++x ) {
			for( int y=0; y<app.bdheight; ++y ) {
				table[x][y] = table[x+1][y];
			}
		}
		for( int y=0; y<app.bdheight; ++y ) {
			table[app.bdwidth-1][y] = 0;
		}
		chkcount = 0;
		paint();
		app.checkeddata = false;
	}

	void  moveRight() {
		for( int x=app.bdwidth-1; x>=1; --x ) {
			for( int y=0; y<app.bdheight; ++y ) {
				table[x][y] = table[x-1][y];
			}
		}
		for( int y=0; y<app.bdheight; ++y ) {
			table[0][y] = 0;
		}
		chkcount = 0;
		paint();
		app.checkeddata = false;
	}

	void  moveUp() {
		for( int y=0; y<app.bdheight-1; ++y )
			for( int x=0; x<app.bdwidth; ++x ) {
				table[x][y] = table[x][y+1];
		}
		for( int x=0; x<app.bdwidth; ++x ) {
			table[x][app.bdheight-1] = 0;
		}
		chkcount = 0;
		paint();
		app.checkeddata = false;
	}

	void  moveDown() {
		for( int y=app.bdheight-1; y>=1; --y )
			for( int x=0; x<app.bdwidth; ++x ) {
				table[x][y] = table[x][y-1];
		}
		for( int x=0; x<app.bdwidth; ++x ) {
			table[x][0] = 0;
		}
		chkcount = 0;
		paint();
		app.checkeddata = false;
	}

	//------------------------------ MakePanel
	//	送信データを作成する
	//----------------------------------------
	String	makesolvedata() {
		String SendData = "";
		SendData += "size  " + app.bdwidth  + " " + app.bdheight + "\n";
		SendData += "begin\n";

		for( int i=0; i<app.bdwidth; ++i ) {
			int	len = 0;
			String str = "";
			for( int j=0; j<app.bdheight; ++j ) {
				int	v = table[i][j];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					str += ( (str.length()!=0) ? " " : "") + len;
					len = 0;
				}
			}
			if( len > 0 ) {
				str += ( (str.length()!=0) ? " " : "") + len;
			}
			if( str.length() == 0 )
				str = "-";
			SendData += str + "\n";
		}

		for( int i=0; i<app.bdheight; ++i ) {
			int	len = 0;
			String str = "";
			for( int j=0; j<app.bdwidth; ++j ) {
				int	v = table[j][i];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					str += ( (str.length()!=0) ? " " : "") + len;
					len = 0;
				}
			}
			if( len > 0 ) {
				str += ( (str.length()!=0) ? " " : "") + len;
			}
			if( str.length() == 0 )
				str = "-";
			SendData += str + "\n";
		}

		SendData += "end\n";

		return	SendData;
	}

	//-------------------------------------- MakePanel
	//	ヒントデータを作成するために奥行きを伸ばす
	//------------------------------------------------
	void	prolongdepth() {

		int vdepth = 1;
		int hdepth = 1;

		for( int i=0; i<app.bdwidth; ++i ) {
			int	len = 0;
			int	d = 0;
			for( int j=0; j<app.bdheight; ++j ) {
				int	v = table[i][j];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					++d;
					len = 0;
				}
			}
			if( len > 0 ) {
				++d;
			}
			if( vdepth < d )
				vdepth = d;
		}

		for( int i=0; i<app.bdheight; ++i ) {
			int	len = 0;
			int	d = 0;
			for( int j=0; j<app.bdwidth; ++j ) {
				int	v = table[j][i];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					++d;
					len = 0;
				}
			}
			if( len > 0 ) {
				++d;
			}
			if( hdepth < d )
				hdepth = d;
		}

		app.playPanel.vdepth = vdepth;
		app.playPanel.hdepth = hdepth;
		app.playPanel.resize();
	}

	//------------------------------ MakePanel
	//	ヒントデータを作成する
	//----------------------------------------
	void	sethintdata() {
		int	vals[] = new int[100];
		int	nvals;

		app.cheatPanel.vHint.resizeHint();
		app.cheatPanel.hHint.resizeHint();
		app.playPanel.vHint.resizeHint();
		app.playPanel.hHint.resizeHint();

		for( int i=0; i<app.bdwidth; ++i ) {
			int	len = 0;
			nvals = 0;
			for( int j=0; j<app.bdheight; ++j ) {
				int	v = table[i][j];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					vals[nvals++] = len;
					len = 0;
				}
			}
			if( len > 0 ) {
				vals[nvals++] = len;
			}
			app.cheatPanel.vHint.setValues( i, nvals, vals );
			app.playPanel.vHint.setValues( i, nvals, vals );
		}

		for( int i=0; i<app.bdheight; ++i ) {
			int	len = 0;
			nvals = 0;
			for( int j=0; j<app.bdwidth; ++j ) {
				int	v = table[j][i];
				if( v == 1 ) {
					++len;
				} else if( len > 0 ) {
					vals[nvals++] = len;
					len = 0;
				}
			}
			if( len > 0 ) {
				vals[nvals++] = len;
			}
			app.cheatPanel.hHint.setValues( i, nvals, vals );
			app.playPanel.hHint.setValues( i, nvals, vals );
		}
	}

	//------------------------------ MakePanel
	//	解答の最初のデータを移す
	//----------------------------------------
	void copyfirstanswer() {
		clearTable();
		if( app.answer.anscount < 1 )
			return;
		for( int i=0; i<app.bdwidth; ++i ) {
			for( int j=0; j<app.bdheight; ++j ) {
				table[i][j] = app.answer.table[0][i][j];
			}
		}				
	}

	//------------------------------ MakePanel
	//	 チェック
	//----------------------------------------
	void check() {
		chkcount = 0;
		paint();
		update( getGraphics() );

		prolongdepth();
		sethintdata();

		if( app.answer.solve( makesolvedata() ) ) {
			chkcount = app.answer.anscount;
			paint();
		}
		app.checkeddata = (chkcount == 1);
	}

	//------------------------------ MakePanel
	//	ボタンが押された時の処理
	//----------------------------------------
	public boolean action( Event evt, Object obj ) {

		if( "Redraw".equals(obj) ) {		// 再描画
			chkcount = 0;
			paint();
			return true;
		}

		if( "L".equals(obj) ) {
			moveLeft();
			return true;
		}
		if( "U".equals(obj) ) {
			moveUp();
			return true;
		}
		if( "D".equals(obj) ) {
			moveDown();
			return true;
		}
		if( "R".equals(obj) ) {
			moveRight();
			return true;
		}

		return false;
	}

	//------------------------------ MakePanel
	//	解答の表示
	//----------------------------------------
	void paint() {
		if( chkcount == 0 ) {
			showError( 0 );
 		} else {
			showError( chkcount==1 ? 1 : -1 );
		}

		if( !isValid() )
			return;

		canvas.paint( canvas.getGraphics() );
	}
}

//================================================================================
//	解答
//================================================================================
class  Answer {
	Applet		applet;
	Nonogram	app;
	int		table[][][];
	int		anscount = 0;

	//----------------------------------------
	//	構築子
	//----------------------------------------
	Answer( Nonogram a ) {
		app = a;
		applet = app.applet;
		resize();
	}

	//----------------------------------------
	//	テーブルのリサイズ
	//----------------------------------------
	void  resize() {
		table = new int[2][app.bdwidth][app.bdheight];
		anscount = 0;
	}

	//----------------------------------------
	//	テーブルのクリア
	//----------------------------------------
	void  clearTable() {
		resize();

		for( int x=0; x<app.bdwidth; ++x )
			for( int y=0; y<app.bdheight; ++y )
				table[0][x][y] = table[1][x][y] = -1;
	}

	//----------------------------------------
	//	テーブルのセット
	//----------------------------------------
	void  setTable( int idx, int x, int y, int v ) {
		if( idx < 0 || 2 <= idx  )
			return;
		if( x < 0 || app.bdwidth <= x )
			return;
		if( y < 0 || app.bdheight <= y )
			return;
		table[idx][x][y] = v;
	}

	//----------------------------------------
	//	解く（ＣＧＩ）
	//----------------------------------------
	boolean	solve( String probdata ) {
		URL	url;
		StringBuffer str = new StringBuffer(); 
		String	s ="http://www.pro.or.jp/cgi-bin/fuji/nonogram/nonosolver-v2.pl";

		try {
			url = new URL(s);

			URLConnection uc = url.openConnection();
			uc.setDoOutput(true);
			uc.setDoInput(true);
			uc.setAllowUserInteraction(false);
			DataOutputStream dos = new DataOutputStream(uc.getOutputStream());

			String sendData = "problem=" + probdata;
			dos.writeBytes(sendData);
			dos.close();

			DataInputStream dis = new DataInputStream(uc.getInputStream());
			String	nextline;
			while( (nextline = dis.readLine()) != null ) {
				str.append(nextline + "\n");
			}
			dis.close();
		}
		catch( Exception e ) {
			System.err.println(e);
			return true;
		}

		// System.out.println( "Ans:\n" + str );

		int	answ, ansh;
		int	x = 0;
		int	y = 0;
		clearTable();	// 解答テーブルのクリア

		StringTokenizer st = new StringTokenizer( str.toString() );
		while (st.hasMoreTokens()) {
			String token = st.nextToken();
			if( token.equals( "answer" ) ) {
				anscount = Integer.parseInt( st.nextToken() );
				continue;
			}
			if( token.equals( "size" ) ) {
				answ = Integer.parseInt( st.nextToken() );
				ansh = Integer.parseInt( st.nextToken() );
				y = 0;
				continue;
			}
			for( x=0; x<token.length(); ++x ) {
				int v = Integer.parseInt( String.valueOf(token.charAt(x)) );
				setTable( anscount-1, x, y, v );
			}
			++y;
		}

		// System.out.println( "anscount="+anscount );
		return	true;
	}

	//----------------------------------------
	//	ポストする（問題を送る）
	//----------------------------------------
	boolean	post( String probdata ) {
		URL	url;
		StringBuffer str = new StringBuffer(); 
		String	s ="http://www.pro.or.jp/cgi-bin/fuji/nonogram/nonopost.pl";

		try {
			url = new URL(s);

			URLConnection uc = url.openConnection();
			uc.setDoOutput(true);
			uc.setDoInput(true);
			uc.setAllowUserInteraction(false);
			DataOutputStream dos = new DataOutputStream(uc.getOutputStream());

			String sendData = "problem=" + probdata;
			dos.writeBytes(sendData);
			dos.close();

			DataInputStream dis = new DataInputStream(uc.getInputStream());
			String	nextline;
			while( (nextline = dis.readLine()) != null ) {
				str.append(nextline + "\n");
			}
			dis.close();
			return true;
		}
		catch( Exception e ) {
			System.err.println(e);
			return true;
		}
	}
}

//================================================================================
//	１ライン分のデータ処理
//================================================================================
class  LineData extends Panel {
	Nonogram	app;
	CheatPanel	panel;
	GridBagLayout		gbl;
	GridBagConstraints	gbc;

	TextField	text;
	Font		font;	
	ControlButton	clearbtn;		// クリアボタン
	int		vals[] = new int[100];
	int		valnum;

	//----------------------------------------
	//	構築子
	//----------------------------------------
	LineData( Nonogram a, CheatPanel p ) {
		app   = a;
		panel = p;

		gbl = new GridBagLayout();
		gbc = new GridBagConstraints();
		setLayout( gbl );

		gbl.columnWidths = new int[4];
		gbl.rowHeights   = new int[4];

		gbl.columnWidths[0] = gbl.columnWidths[3] = 20; 
		gbl.rowHeights[2]   = 15;

		text = new TextField();
		font = new Font( "Courier", 0, 20 );
		text.setFont( font );

		Canvas dummy = new Canvas();
		dummy.resize( 150, 30 );
		gbc.gridx = 1;
		gbc.gridy = 0;
		gbc.gridwidth  = 3;
		gbc.gridheight = 1;
		gbc.fill = GridBagConstraints.NONE;
		gbl.setConstraints( dummy, gbc );
		add( dummy );

		gbc.gridx = 1;
		gbc.gridy = 1;
		gbc.gridwidth  = 2;
		gbc.gridheight = 1;
		gbc.weightx = 1.0;
		gbc.weighty = 0.0;
		gbc.fill = GridBagConstraints.HORIZONTAL;
		gbl.setConstraints( text, gbc );
		add( text );

		clearbtn = new ControlButton( app, "Clear" );
		clearbtn.setFont( app.btnfont );

		gbc.gridx = 1;
		gbc.gridy = 3;
		gbc.gridwidth  = 1;
		gbc.gridheight = 1;
		gbc.weightx = 0.0;
		gbc.weighty = 1.0;
		gbc.fill = GridBagConstraints.NONE;
		gbc.anchor = GridBagConstraints.NORTHWEST;
		gbl.setConstraints( clearbtn, gbc );
		add( clearbtn );
	}

	//----------------------------------------
	//	入力バッファのクリア
	//----------------------------------------
	void clear() {
		text.setText( "" );
	}

	//----------------------------------------
	//	アクティブ行を入力データにセット
	//----------------------------------------
	void backData() {
		text.setText( panel.getLine() );
	}

	//----------------------------------------
	//	入力データをアクティブ行にセット
	//----------------------------------------
	void setData() {
		String txt = text.getText().replace( '.', ' ' );
		StringTokenizer st = new StringTokenizer( txt );
		valnum = 0;
		while( st.hasMoreTokens() ) {
			String s = st.nextToken();
			int	i;
			try {
				i = Integer.parseInt( s );
			} catch( NumberFormatException e ) {
				i = 0;
			}
			vals[valnum++] = i;
		}
		
		if( panel.hHint.activeline >= 0 ) {
			int ln = panel.hHint.activeline;
			panel.incactive();
			panel.hHint.setValues( ln, valnum, vals );
		} else if( panel.vHint.activeline >= 0 ) {
			int ln = panel.vHint.activeline;
			panel.incactive();
			panel.vHint.setValues( ln, valnum, vals );
		}

		backData();
		panel.paint();
	}
}

//================================================================================
//	ヒントテーブル（縦・横）
//================================================================================
class  HintTable  {
	Nonogram	app;
	char		dir;		// 'v' or 'h'
	boolean	  	play;		// true:playpanel, false:cheatpanel
	CommonPanel	panel;

	ScrollableHintTable	hinttable;
	Scrollbar		hbar, vbar;
	boolean			hadd, vadd;	// 親パネルに加えられているか
	int		hints[][];
	int		maxdepth;	// depth最大値（１以上）
	boolean		marked[][];

	int		uvw, uvh;	// 見える範囲の枠数
	int		ufw, ufh;	// 全体の枠数
	int		hval, vval;	// スクロールバーの位置
	int		hmax, vmax;	// スクロールバー最大位置
	int		activeline;	// アクティブ行

	//----------------------------------------
	//	構築子
	//		hb, vb	: 水平垂直バーの生成
	//----------------------------------------
	HintTable( Nonogram a, CommonPanel pn, Dimension ps, char d, boolean pl ) {

		app = a;
		panel = pn;
		play = pl;
		dir = d;
		hbar = vbar = null;

		int	unit = app.unit;

		if( dir == 'v' ) {
			activeline = -1;
			ufw = app.bdwidth;
			ufh = panel.vdepth;
			uvw = panel.uvw;
			uvh = ufh;
			hinttable = new ScrollableHintTable( this, panel, d, play );
			panel.add( hinttable );
			hinttable.resize( unit*uvw+1, unit*uvh+1 );

			// 水平スクロールバーの生成
			hbar = new Scrollbar( Scrollbar.HORIZONTAL );
			hmax = ufw-uvw;
			hval = 0;
			hbar.setValues( hval, uvw, 0, hmax );

			// 垂直スクロールバーの生成
			vbar = new Scrollbar( Scrollbar.VERTICAL );

			vval = vmax = ufh-uvh;
			vbar.setValues( vval, uvh, 0, vmax );
		}

		if( dir == 'h' ) {
			activeline = 0;
			ufw = panel.hdepth;
			ufh = app.bdheight;
			uvw = ufw;
			uvh = panel.uvh;
			hinttable = new ScrollableHintTable( this, panel, d, play );
			panel.add( hinttable );
			hinttable.resize( unit*uvw+1, unit*uvh+1 );

			// 水平スクロールバーの生成
			hbar = new Scrollbar( Scrollbar.HORIZONTAL );

			hval = hmax = ufw-uvw;
			hbar.setValues( hval, uvw, 0, hmax );

			// 垂直スクロールバーの生成
			vbar = new Scrollbar( Scrollbar.VERTICAL );
			vmax = ufh-uvh;
			vval = 0;
			vbar.setValues( vval, uvh, 0, vmax );
		}

		resizeHint();
	}

	//----------------------------------------
	//	ウィンドウのサイズが変更された
	//----------------------------------------
	void resizeWindow() {
		int	unit = app.unit;

		if( dir == 'v' ) {
			uvw = panel.uvw;
			hinttable.resize( unit*uvw+1, unit*uvh+1 );

			// 水平スクロールバー
			hmax = ufw-uvw;
			hval = 0;
			hbar.setValues( hval, uvw, 0, hmax );

			// 垂直スクロールバー
			vmax = ufh-uvh;
		}

		if( dir == 'h' ) {
			uvh = panel.uvh;
			hinttable.resize( unit*uvw+1, unit*uvh+1 );

			// 水平スクロールバー
			hmax = ufw-uvw;

			// 垂直スクロールバー
			vmax = ufh-uvh;
			vval = 0;
			vbar.setValues( vval, uvh, 0, vmax );
		}

		hinttable.resize();

		if( hbar != null ) {
			if( hmax > 0 ) {
				if( !hadd ) {
					panel.add( hbar );
					hadd = true;
				}
				hbar.show( true );
				hbar.setValues( hval, uvw, 0, hmax );
			} else {
				if( hadd ) {
					panel.remove( hbar );
					hadd = false;
				}
			}
		}
		if( vbar != null ) {
			if( vmax > 0 ) {
				if( !vadd ) {
					panel.add( vbar );
					vadd = true;
				}
				vbar.show( true );
				vbar.setValues( vval, uvh, 0, vmax );
			} else {
				if( vadd ) {
					panel.remove( vbar );
					vadd = false;
				}
			}
		}
	}

	//----------------------------------------
	//	移動した
	//----------------------------------------
	void moved() {
		if( hbar!=null &&  hbar.isVisible() ) {
			hval = hbar.getValue();
		}
		if( vbar!=null && vbar.isVisible() ) {
			vval = vbar.getValue();
		}

		paint();
	}

	//----------------------------------------
	//	クリア変更
	//----------------------------------------
	void clear() {
		clearHint();
		hinttable.clear();
		paint();
	}

	//----------------------------------------
	//	ヒントテーブルのリサイズ
	//----------------------------------------
	void resizeHint() {
		hints = new int[dir=='v'? ufw:ufh][];
		marked = play ? new boolean[dir=='v'? ufw:ufh][] : null;
		clearHint();
	}

	//----------------------------------------
	//	ヒントテーブルのクリア
	//----------------------------------------
	void clearHint() {
		for( int i=0; i<hints.length; ++i ) {
			hints[i]  = new int[0];
			if( marked != null )
				marked[i] = new boolean[0];
		}
	}

	//----------------------------------------
	//	マークテーブルのクリア
	//----------------------------------------
	void clearMarked() {
		if( marked == null )
			return;

		for( int i=0; i<marked.length; ++i )
			for( int j=0; j<marked[i].length; ++j ) {
				marked[i][j] = false;
			}
	}

	//----------------------------------------
	//	値の取得
	//----------------------------------------
	int gethint( int x, int y ) {
		if( dir == 'v' ) {
			int	len = hints[x].length;
			int	t = y - (panel.vdepth-len);
			if( 0<=t && t<len )
				return	hints[x][t];
		}
		if( dir == 'h' ) {
			int	len = hints[y].length;
			int	t = x - (panel.hdepth-len);
			if( 0<=t && t<len )
				return	hints[y][t];
		}
		return	0;
	}

	boolean getmark( int x, int y ) {
		if( dir == 'v' ) {
			int	len = hints[x].length;
			int	t = y - (panel.vdepth-len);
			if( 0<=t && t<len )
				return	marked[x][t];
		}
		if( dir == 'h' ) {
			int	len = hints[y].length;
			int	t = x - (panel.hdepth-len);
			if( 0<=t && t<len )
				return	marked[y][t];
		}
		return	false;
	}

	void revmark( int x, int y ) {
		if( dir == 'v' ) {
			int	len = hints[x].length;
			int	t = y - (panel.vdepth-len);
			if( 0<=t && t<len ) {
				marked[x][t] = ! marked[x][t];
			}
		}
		if( dir == 'h' ) {
			int	len = hints[y].length;
			int	t = x - (panel.hdepth-len);
			if( 0<=t && t<len )
				marked[y][t] = ! marked[y][t];
		}
	}

	//----------------------------------------
	//	値のセット
	//----------------------------------------
	void setValues( int linenum, int n, int vals[] ) {
		if( dir == 'v' ) {
			int x = linenum;
			if( x < 0 || x >= ufw )
				return;
			if( panel.vdepth < n ) {
				uvh = ufh = panel.vdepth = n;
				hinttable.fullCanvas = null;	// OFFイメージ消去
				panel.resizeWindow();
			}

			hints[x]  = new int[n];
			if( play ) {
				marked[x] = new boolean[n];
			}
			for( int i=0; i<n; ++i ) {
				hints[x][i] = vals[i];
			} 
			for( int y=0; y<panel.vdepth; ++y ) {
				hinttable.drawNumber( x, y );
			}
		}

		if( dir == 'h' ) {
			int y = linenum;
			if( y < 0 || y >= ufh )
				return;
			if( panel.hdepth < n ) {
				uvw = ufw = panel.hdepth = n;
				hinttable.fullCanvas = null;	// OFFイメージ消去
				panel.resizeWindow();				
			}

			hints[y]  = new int[n];
			if( play ) {
				marked[y] = new boolean[n];
			}
			for( int i=0; i<n; ++i ) {
				hints[y][i] = vals[i];
			} 
			for( int x=0; x<panel.hdepth; ++x ) {
				hinttable.drawNumber( x, y );
			}
		}

		if( maxdepth < n )
			maxdepth = n;

		hinttable.paint( hinttable.getGraphics() );
	}

	//----------------------------------------
	//	サイズ変更
	//----------------------------------------
	void resize() {
		if( dir == 'v' ) {
			ufw = app.bdwidth;
			ufh = panel.vdepth;
			uvh = ufh;

			hmax = ufw-uvw;
			hval = 0;

			vmax = ufh-uvh;
			vval = vmax;

			activeline = -1;
		}
		if( dir == 'h' ) {
			ufw = panel.hdepth;
			ufh = app.bdheight;
			uvw = ufw;

			hmax = ufw-uvw;
			hval = hmax;

			vmax = ufh-uvh;
			vval = 0;

			activeline = 0;
		}

		if( hbar != null ) {
			if( hmax > 0 ) {
				hbar.show( true );
				hbar.setValues( hval, uvw, 0, hmax );
			} else {
				hbar.show( false );
			}
		}
		if( vbar != null ) {
			if( vmax > 0 ) {
				vbar.show( true );
				vbar.setValues( vval, uvh, 0, vmax );
			} else {
				vbar.show( false );
			}
		}

		// ヒントテーブルのサイズ変更
		resizeHint();
		hinttable.resize();
		
		paint();
	}

	//----------------------------------------
	//	ペイント
	//----------------------------------------
	public void paint() {
		hinttable.paint( hinttable.getGraphics() );
	}
}

//================================================================================
//	ヒントテーブル（スクロールキャンバス）
//================================================================================
class  ScrollableHintTable  extends Canvas {
	Nonogram  app;
	CommonPanel     panel;	// 親パネル
	boolean	  play;		// true:playpanel, false:cheatpanel
	HintTable   hintTable;
	char	dir;
	Image	fullCanvas;
	Image	fullCanvasWhite;
	Image	fullCanvasActive;
	Image	clipCanvasActive;
	Graphics  fg, fgw, fga;
	int	vw, vh;		// ドット単位でのビューサイズ
	int	fw, fh;		// ドット単位でのフルサイズ
	Font	font;

	//----------------------------------------
	//	構築子 
	//----------------------------------------
	ScrollableHintTable( HintTable ht, CommonPanel p, char d, boolean pl ) {
		hintTable = ht;
		panel = p;
		app = ht.app;
		dir = d;
		play = pl;		
		resize();
	}

	//----------------------------------------
	//	テーブルサイズ変更 
	//----------------------------------------
	void resize() {
		fw = hintTable.ufw * app.unit + 1;
		fh = hintTable.ufh * app.unit + 1;
		vw = hintTable.uvw * app.unit + 1;
		vh = hintTable.uvh * app.unit + 1;
		fullCanvas = null;
		font = null;
		fg = null;
	}

	//----------------------------------------
	//	ＯＦＦイメージの生成
	//----------------------------------------
	void createImages() {
		if( fullCanvas != null )
			return;

		fullCanvas = app.applet.createImage( fw, fh );
		fg = fullCanvas.getGraphics();
		fullCanvasWhite  = app.applet.createImage( fw, fh );
		fgw = fullCanvasWhite.getGraphics();
		fullCanvasActive = app.applet.createImage( fw, fh );
		fga = fullCanvasActive.getGraphics();

		int  unit = panel.unit;
		int  w, h;

		if( dir == 'h' ) {
			h = unit;
			w = unit*hintTable.ufw;
		} else {
			h = unit*hintTable.ufh;
			w = unit;
		}
		clipCanvasActive = app.applet.createImage( w, h );

		paintAll();
	}

	//----------------------------------------
	//	クリア（フルサイズ画面の枠の描画）
	//----------------------------------------
	void clear() {
		int unit = panel.unit;

		fgw.setColor( Color.white );
		fgw.fillRect( 0, 0, fw, fh );

		fga.setColor( Color.cyan );
		fga.fillRect( 0, 0, fw, fh );

		fgw.setColor( Color.lightGray );
		fga.setColor( Color.lightGray );
		for( int i=0; i<=hintTable.ufw; ++i ) {
			fgw.drawLine( unit*i, 0, unit*i, unit*hintTable.ufh );
			fga.drawLine( unit*i, 0, unit*i, unit*hintTable.ufh );
		}
		for( int i=0; i<=hintTable.ufh; ++i ) {
			fgw.drawLine( 0, unit*i, unit*hintTable.ufw, unit*i );
			fga.drawLine( 0, unit*i, unit*hintTable.ufw, unit*i );
		}
		fgw.setColor( Color.darkGray );
		fga.setColor( Color.darkGray );
		if( dir == 'v' ) {
			for( int i=0; i<=hintTable.ufw; i+=5 ) {
				fgw.drawLine( unit*i, 0, unit*i, unit*hintTable.ufh );
				fga.drawLine( unit*i, 0, unit*i, unit*hintTable.ufh );
			}
		}
		if( dir == 'h' ) {
			for( int i=0; i<=hintTable.ufh; i+=5 ) {
				fgw.drawLine( 0, unit*i, unit*hintTable.ufw, unit*i );
				fga.drawLine( 0, unit*i, unit*hintTable.ufw, unit*i );
			}
		}

		addImages();
	}

	//----------------------------------------
	//	フルサイズ画面の描画（枠）
	//		白とアクティブを重ねる
	//		activelineの変更の度に呼び出す。
	//----------------------------------------
	void addImages() {
		createImages();

		fg.drawImage( fullCanvasWhite, 0, 0, fw, fh, this );

		if( hintTable.activeline >= 0 ) {
			int  unit = panel.unit;
			int  x, y;

			if( dir == 'h' ) {
				x = 0;
				y = unit*hintTable.activeline;
			} else {
				x = unit*hintTable.activeline;
				y = 0;
			}

			Graphics cg = clipCanvasActive.getGraphics();
			cg.drawImage( fullCanvasActive, -x, -y, this );
			fg.drawImage( clipCanvasActive, x, y, this );
		}
	}

	void paintAll() {
		clear();
		for( int x=0; x<hintTable.ufw; ++x ) {
			for( int y=0; y<hintTable.ufh; ++y ) {
				drawNumber( x, y );
			}
		}

		addImages();
	}

	//----------------------------------------
	//	数値の描画
	//		(x,y)は左上からの位置
	//----------------------------------------
	void drawNumber( int x, int y ) {
		int	v = 0;
		boolean	m = false;

		if( dir == 'v' ) {
			int  len = hintTable.hints[x].length;
			if( hintTable.ufh-len<=y && y<hintTable.ufh ) {
				v = hintTable.hints[x][y-(hintTable.ufh-len)];
				if( play ) {
					m = hintTable.marked[x][y-(hintTable.ufh-len)];
				}
			}
		}
		if( dir == 'h' ) {
			int  len = hintTable.hints[y].length;
			if( hintTable.ufw-len<=x && x<hintTable.ufw ) {
				v = hintTable.hints[y][x-(hintTable.ufw-len)];
				if( play ) {
					m = hintTable.marked[y][x-(hintTable.ufw-len)];
				}
			}
		}

		drawNumber( x, y, v, m );
	}

	void drawNumber( int x, int y, int v, boolean mk ) {
		int unit = panel.unit;

		if( fg == null ) {
			paint( getGraphics() );
		}

		fgw.setColor( Color.white );
		fga.setColor( Color.cyan );
		
		fgw.fillRect( x*unit+1, y*unit+1, unit-1, unit-1 );
		fga.fillRect( x*unit+1, y*unit+1, unit-1, unit-1 );

		if( play && mk ) {
			fgw.setColor( Color.lightGray );
			fga.setColor( Color.lightGray );
			fgw.fillRect( x*unit+2, y*unit+2, unit-3, unit-3 );
			fga.fillRect( x*unit+2, y*unit+2, unit-3, unit-3 );
		}

		if( v == 0 )
			return;

		if( font == (Font)null ) {
			font = new Font( "Helvetica", 0, unit*9/10 );
		}
		fgw.setColor( Color.black );
		fga.setColor( Color.black );

		fgw.setFont( font );
		fga.setFont( font );
		String s = String.valueOf( v );

		FontMetrics fm = fgw.getFontMetrics();
		int	sWidth = fm.stringWidth(s);
		int	sHeight = fm.getHeight();
		int	sAscent = fm. getAscent();

		fgw.drawString( s, x*unit + (unit-sWidth)/2 +1, y*unit + (unit+sAscent)/2 );
		fga.drawString( s, x*unit + (unit-sWidth)/2 +1, y*unit + (unit+sAscent)/2 );
	}

	//----------------------------------------
	//	描画
	//		描画は、フルサイズ画面の内容を移すだけである。
	//----------------------------------------
	public void paint( Graphics g ) {
		if( g == null )
			return;

		createImages();

		int  unit = app.unit;

		addImages();

		g.drawImage( fullCanvas, -hintTable.hval*unit, -hintTable.vval*unit, this );
	}

	//----------------------------------------
	//	マウスの押し下げ
	//----------------------------------------
	public boolean mouseDown( Event evt, int x, int y ) {
		int  ix = x/panel.unit + hintTable.hval;
		int  iy = y/panel.unit + hintTable.vval;
		if( ix<0 || hintTable.ufw<=ix || iy<0 || hintTable.ufh<=iy )
			return	true;		// 無視

		if( play ) {
			if( dir == 'v' ) {
				if( hintTable.gethint(ix,iy) != 0 ) {
					hintTable.revmark(ix,iy);
					drawNumber( ix, iy );
				}
			} else {
				if( hintTable.gethint(ix,iy) != 0 ) {
					hintTable.revmark(ix,iy);
					drawNumber( ix, iy );
				}
			}
		} else {	// Cheat
			panel.vHint.activeline = -1;
			panel.hHint.activeline = -1;
		}

		if( dir == 'v' ) {
			panel.vHint.activeline = ix;
		} else {
			panel.hHint.activeline = iy;
		}

		addImages();

		if( !play )
			app.cheatPanel.linedata.backData();
		panel.paint();
		return true;
       }

	//----------------------------- PlayCanvas
	// 	マウスの移動
	//----------------------------------------
	public boolean mouseMove( Event evt, int x, int y ) {
		if( ! play )
			return true;

		int  ix = x/panel.unit + hintTable.hval;
		int  iy = y/panel.unit + hintTable.vval;
		if( ix<0 || hintTable.ufw<=ix || iy<0 || hintTable.ufh<=iy )
			return	true;		// 無視

		if( dir == 'v' ) {
			panel.vHint.activeline = ix;
		} else {
			panel.hHint.activeline = iy;
		}

		addImages();
		paint( getGraphics() );

		return	true;
	}
}

//================================================================================
//	制御ボタンクラス
//================================================================================
class  ControlButton extends Button {
	Nonogram	app;

	// 構築子
	ControlButton( Nonogram ns, String str ) {
		super();
		app = ns;
		setLabel( str );
		setFont( app.btnfont );
	}
}

//================================================================================
//		end of "NonogramApplet.java",  by Hirofumi Fujiwara
//================================================================================