768 lines
25 KiB
Java
768 lines
25 KiB
Java
/*
|
|
* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
@bug 6392086 8014725
|
|
@summary Tests basic DnD functionality in an applet
|
|
@author Alexey Utkin, Semyon Sadetsky
|
|
@run applet HTMLTransferTest.html
|
|
*/
|
|
|
|
/**
|
|
* HTMLTransferTest.java
|
|
*
|
|
* summary: tests that HTMLs of all supported native HTML formats
|
|
* are transfered properly
|
|
*/
|
|
|
|
import java.applet.Applet;
|
|
import java.awt.*;
|
|
import java.awt.datatransfer.*;
|
|
import java.io.*;
|
|
|
|
|
|
public class HTMLTransferTest extends Applet {
|
|
public static final int CODE_NOT_RETURNED = 100;
|
|
public static final int CODE_CONSUMER_TEST_FAILED = 101;
|
|
public static final int CODE_FAILURE = 102;
|
|
public static DataFlavor[] HTMLFlavors = null;
|
|
public static DataFlavor SyncFlavor = null;
|
|
static {
|
|
try{
|
|
HTMLFlavors = new DataFlavor[] {
|
|
new DataFlavor("text/html; document=selection; Class=" + InputStream.class.getName() + "; charset=UTF-8"),
|
|
new DataFlavor("text/html; document=selection; Class=" + String.class.getName() + "; charset=UTF-8")
|
|
};
|
|
SyncFlavor = new DataFlavor(
|
|
"application/x-java-serialized-object; class="
|
|
+ SyncMessage.class.getName()
|
|
+ "; charset=UTF-8"
|
|
);
|
|
}catch(Exception e){
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private THTMLProducer imPr;
|
|
private int returnCode = CODE_NOT_RETURNED;
|
|
|
|
public void init() {
|
|
initImpl();
|
|
|
|
String[] instructions =
|
|
{
|
|
"This is an AUTOMATIC test",
|
|
"simply wait until it is done"
|
|
};
|
|
Sysout.createDialog( );
|
|
Sysout.printInstructions( instructions );
|
|
|
|
} // init()
|
|
|
|
private void initImpl() {
|
|
imPr = new THTMLProducer();
|
|
imPr.begin();
|
|
}
|
|
|
|
|
|
public void start() {
|
|
try {
|
|
String stFormats = "";
|
|
|
|
String iniMsg = "Testing formats from the list:\n";
|
|
for (int i = 0; i < HTMLTransferTest.HTMLFlavors.length; i++) {
|
|
stFormats += "\"" + HTMLTransferTest.HTMLFlavors[i].getMimeType() + "\"\n";
|
|
}
|
|
Sysout.println(iniMsg + stFormats);
|
|
System.err.println("===>" + iniMsg + stFormats);
|
|
|
|
String javaPath = System.getProperty("java.home", "");
|
|
String cmd = javaPath + File.separator + "bin" + File.separator
|
|
+ "java -cp " + System.getProperty("test.classes", ".") +
|
|
//+ "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 "
|
|
" THTMLConsumer"
|
|
//+ stFormats
|
|
;
|
|
|
|
Process process = Runtime.getRuntime().exec(cmd);
|
|
ProcessResults pres = ProcessResults.doWaitFor(process);
|
|
returnCode = pres.exitValue;
|
|
|
|
if (pres.stderr != null && pres.stderr.length() > 0) {
|
|
System.err.println("========= Child VM System.err ========");
|
|
System.err.print(pres.stderr);
|
|
System.err.println("======================================");
|
|
}
|
|
|
|
if (pres.stdout != null && pres.stdout.length() > 0) {
|
|
System.err.println("========= Child VM System.out ========");
|
|
System.err.print(pres.stdout);
|
|
System.err.println("======================================");
|
|
}
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
//returnCode equals CODE_NOT_RETURNED
|
|
}
|
|
|
|
switch (returnCode) {
|
|
case CODE_NOT_RETURNED:
|
|
System.err.println("Child VM: failed to start");
|
|
break;
|
|
case CODE_FAILURE:
|
|
System.err.println("Child VM: abnormal termination");
|
|
break;
|
|
case CODE_CONSUMER_TEST_FAILED:
|
|
throw new RuntimeException("test failed: HTMLs in some " +
|
|
"native formats are not transferred properly: " +
|
|
"see output of child VM");
|
|
default:
|
|
boolean failed = false;
|
|
String passedFormats = "";
|
|
String failedFormats = "";
|
|
|
|
for (int i = 0; i < imPr.passedArray.length; i++) {
|
|
if (imPr.passedArray[i]) {
|
|
passedFormats += HTMLTransferTest.HTMLFlavors[i].getMimeType() + " ";
|
|
} else {
|
|
failed = true;
|
|
failedFormats += HTMLTransferTest.HTMLFlavors[i].getMimeType() + " ";
|
|
}
|
|
}
|
|
if (failed) {
|
|
throw new RuntimeException(
|
|
"test failed: HTMLs in following "
|
|
+ "native formats are not transferred properly: "
|
|
+ failedFormats
|
|
);
|
|
} else {
|
|
System.err.println(
|
|
"HTMLs in following native formats are "
|
|
+ "transferred properly: "
|
|
+ passedFormats
|
|
);
|
|
}
|
|
}
|
|
|
|
} // start()
|
|
|
|
} // class HTMLTransferTest
|
|
|
|
class SyncMessage implements Serializable {
|
|
String msg;
|
|
|
|
public SyncMessage(String sync) {
|
|
this.msg = sync;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
return this.msg.equals(((SyncMessage)obj).msg);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return msg;
|
|
}
|
|
}
|
|
|
|
class ProcessResults {
|
|
public int exitValue;
|
|
public String stdout;
|
|
public String stderr;
|
|
|
|
public ProcessResults() {
|
|
exitValue = -1;
|
|
stdout = "";
|
|
stderr = "";
|
|
}
|
|
|
|
/**
|
|
* Method to perform a "wait" for a process and return its exit value.
|
|
* This is a workaround for <code>Process.waitFor()</code> never returning.
|
|
*/
|
|
public static ProcessResults doWaitFor(Process p) {
|
|
ProcessResults pres = new ProcessResults();
|
|
|
|
InputStream in = null;
|
|
InputStream err = null;
|
|
|
|
try {
|
|
in = p.getInputStream();
|
|
err = p.getErrorStream();
|
|
|
|
boolean finished = false;
|
|
|
|
while (!finished) {
|
|
try {
|
|
while (in.available() > 0) {
|
|
pres.stdout += (char)in.read();
|
|
}
|
|
while (err.available() > 0) {
|
|
pres.stderr += (char)err.read();
|
|
}
|
|
// Ask the process for its exitValue. If the process
|
|
// is not finished, an IllegalThreadStateException
|
|
// is thrown. If it is finished, we fall through and
|
|
// the variable finished is set to true.
|
|
pres.exitValue = p.exitValue();
|
|
finished = true;
|
|
}
|
|
catch (IllegalThreadStateException e) {
|
|
// Process is not finished yet;
|
|
// Sleep a little to save on CPU cycles
|
|
Thread.currentThread().sleep(500);
|
|
}
|
|
}
|
|
if (in != null) in.close();
|
|
if (err != null) err.close();
|
|
}
|
|
catch (Throwable e) {
|
|
System.err.println("doWaitFor(): unexpected exception");
|
|
e.printStackTrace();
|
|
}
|
|
return pres;
|
|
}
|
|
}
|
|
|
|
|
|
abstract class HTMLTransferer implements ClipboardOwner {
|
|
|
|
static final SyncMessage S_PASSED = new SyncMessage("Y");
|
|
static final SyncMessage S_FAILED = new SyncMessage("N");
|
|
static final SyncMessage S_BEGIN = new SyncMessage("B");
|
|
static final SyncMessage S_BEGIN_ANSWER = new SyncMessage("BA");
|
|
static final SyncMessage S_END = new SyncMessage("E");
|
|
|
|
|
|
|
|
Clipboard m_clipboard;
|
|
|
|
HTMLTransferer() {
|
|
m_clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
|
}
|
|
|
|
|
|
abstract void notifyTransferSuccess(boolean status);
|
|
|
|
|
|
static Object createTRInstance(int i) {
|
|
try{
|
|
String _htmlText =
|
|
"The quick <font color='#78650d'>brown</font> <b>mouse</b> jumped over the lazy <b>cat</b>.";
|
|
switch(i){
|
|
case 0:
|
|
return new ByteArrayInputStream(_htmlText.getBytes("utf-8"));
|
|
case 1:
|
|
return _htmlText;
|
|
}
|
|
}catch(UnsupportedEncodingException e){ e.printStackTrace(); }
|
|
return null;
|
|
}
|
|
|
|
static byte[] getContent(InputStream is)
|
|
{
|
|
ByteArrayOutputStream tmp = new ByteArrayOutputStream();
|
|
try{
|
|
int read;
|
|
while( -1 != (read = is.read()) ){
|
|
tmp.write(read);
|
|
};
|
|
} catch( IOException e ) {
|
|
e.printStackTrace();
|
|
}
|
|
return tmp.toByteArray();
|
|
}
|
|
|
|
static void Dump(byte[] b){
|
|
System.err.println( new String(b) );
|
|
};
|
|
|
|
void setClipboardContents(
|
|
Transferable contents,
|
|
ClipboardOwner owner
|
|
) {
|
|
synchronized (m_clipboard) {
|
|
boolean set = false;
|
|
while (!set) {
|
|
try {
|
|
m_clipboard.setContents(contents, owner);
|
|
set = true;
|
|
} catch (IllegalStateException ise) {
|
|
try {
|
|
Thread.sleep(100);
|
|
} catch(InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Transferable getClipboardContents(Object requestor)
|
|
{
|
|
synchronized (m_clipboard) {
|
|
while (true) {
|
|
try {
|
|
Transferable t = m_clipboard.getContents(requestor);
|
|
return t;
|
|
} catch (IllegalStateException ise) {
|
|
try {
|
|
Thread.sleep(100);
|
|
} catch (InterruptedException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
class THTMLProducer extends HTMLTransferer {
|
|
|
|
boolean[] passedArray;
|
|
int fi = 0; // next format index
|
|
private boolean isFirstCallOfLostOwnership = true;
|
|
|
|
THTMLProducer() {
|
|
passedArray = new boolean[HTMLTransferTest.HTMLFlavors.length];
|
|
}
|
|
|
|
void begin() {
|
|
setClipboardContents(
|
|
new HTMLSelection(
|
|
HTMLTransferTest.SyncFlavor,
|
|
S_BEGIN
|
|
),
|
|
this
|
|
);
|
|
}
|
|
|
|
public void lostOwnership(Clipboard cb, Transferable contents) {
|
|
System.err.println("{PRODUCER: lost clipboard ownership");
|
|
Transferable t = getClipboardContents(null);
|
|
if (t.isDataFlavorSupported(HTMLTransferTest.SyncFlavor)) {
|
|
SyncMessage msg = null;
|
|
// for test going on if t.getTransferData() will throw an exception
|
|
if (isFirstCallOfLostOwnership) {
|
|
isFirstCallOfLostOwnership = false;
|
|
msg = S_BEGIN_ANSWER;
|
|
} else {
|
|
msg = S_PASSED;
|
|
}
|
|
try {
|
|
msg = (SyncMessage)t.getTransferData(HTMLTransferTest.SyncFlavor);
|
|
System.err.println("++received message: " + msg);
|
|
} catch (Exception e) {
|
|
System.err.println("Can't getTransferData-message: " + e);
|
|
}
|
|
if( msg.equals(S_PASSED) ){
|
|
notifyTransferSuccess(true);
|
|
} else if( msg.equals(S_FAILED) ){
|
|
notifyTransferSuccess(false);
|
|
} else if (!msg.equals(S_BEGIN_ANSWER)) {
|
|
throw new RuntimeException("wrong message in " +
|
|
"THTMLProducer.lostOwnership(): " + msg +
|
|
" (possibly due to bug 4683804)");
|
|
}
|
|
} else {
|
|
throw new RuntimeException(
|
|
"DataFlavor.stringFlavor is not "
|
|
+ "suppurted by transferable in "
|
|
+ "THTMLProducer.lostOwnership()"
|
|
);
|
|
}
|
|
|
|
if (fi < HTMLTransferTest.HTMLFlavors.length) {
|
|
System.err.println(
|
|
"testing native HTML format \""
|
|
+ HTMLTransferTest.HTMLFlavors[fi].getMimeType()
|
|
+ "\"..."
|
|
);
|
|
//leaveFormat( HTMLTransferTest.HTMLFlavors[fi].getMimeType() );
|
|
setClipboardContents(
|
|
new HTMLSelection(
|
|
HTMLTransferTest.HTMLFlavors[fi],
|
|
HTMLTransferer.createTRInstance(fi)
|
|
),
|
|
this
|
|
);
|
|
} else {
|
|
setClipboardContents(
|
|
new HTMLSelection(
|
|
HTMLTransferTest.SyncFlavor,
|
|
S_END
|
|
),
|
|
null
|
|
);
|
|
}
|
|
System.err.println("}PRODUCER: lost clipboard ownership");
|
|
}
|
|
|
|
|
|
void notifyTransferSuccess(boolean status) {
|
|
passedArray[fi] = status;
|
|
fi++;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
class THTMLConsumer extends HTMLTransferer
|
|
{
|
|
private static final Object LOCK = new Object();
|
|
private static boolean failed;
|
|
int fi = 0; // next format index
|
|
|
|
public void lostOwnership(Clipboard cb, Transferable contents) {
|
|
System.err.println("{CONSUMER: lost clipboard ownership");
|
|
Transferable t = getClipboardContents(null);
|
|
boolean bContinue = true;
|
|
if(t.isDataFlavorSupported(HTMLTransferTest.SyncFlavor)) {
|
|
try {
|
|
SyncMessage msg = (SyncMessage)t.getTransferData(HTMLTransferTest.SyncFlavor);
|
|
System.err.println("received message: " + msg);
|
|
if(msg.equals(S_END)){
|
|
synchronized (LOCK) {
|
|
LOCK.notifyAll();
|
|
}
|
|
bContinue = false;
|
|
}
|
|
} catch (Exception e) {
|
|
System.err.println("Can't getTransferData-message: " + e);
|
|
}
|
|
}
|
|
if(bContinue){
|
|
// all HTML formats have been processed
|
|
System.err.println( "============================================================");
|
|
System.err.println( "Put as " + HTMLTransferTest.HTMLFlavors[fi].getMimeType() );
|
|
boolean bSuccess = false;
|
|
for(int i = 0; i < HTMLTransferTest.HTMLFlavors.length; ++i) {
|
|
System.err.println( "----------------------------------------------------------");
|
|
if( t.isDataFlavorSupported(HTMLTransferTest.HTMLFlavors[i]) ){
|
|
Object im = null; //? HTML;
|
|
try {
|
|
im = t.getTransferData(HTMLTransferTest.HTMLFlavors[i]);
|
|
if (im == null) {
|
|
System.err.println("getTransferData returned null");
|
|
} else {
|
|
System.err.println( "Extract as " + HTMLTransferTest.HTMLFlavors[i].getMimeType() );
|
|
String stIn = "(unknown)", stOut = "(unknown)";
|
|
switch( i ){
|
|
case 0:
|
|
stIn = new String( getContent( (InputStream)HTMLTransferer.createTRInstance(i) ) );
|
|
stOut = new String( getContent((InputStream)im) );
|
|
bSuccess = stIn.equals(stOut);
|
|
break;
|
|
case 1:
|
|
stIn = (String)HTMLTransferer.createTRInstance(i);
|
|
stOut = (String)im;
|
|
int head = stOut.indexOf("<HTML><BODY>");
|
|
if (head >= 0) {
|
|
stOut = stOut.substring(head + 12, stOut.length() - 14);
|
|
}
|
|
bSuccess = stIn.equals(stOut);
|
|
break;
|
|
default:
|
|
bSuccess = HTMLTransferer.createTRInstance(i).equals(im);
|
|
break;
|
|
};
|
|
System.err.println("in :" + stIn);
|
|
System.err.println("out:" + stOut);
|
|
};
|
|
} catch (Exception e) {
|
|
System.err.println("Can't getTransferData: " + e);
|
|
}
|
|
if(!bSuccess)
|
|
System.err.println("transferred DATA is different from initial DATA\n");
|
|
} else {
|
|
System.err.println("Flavor is not supported by transferable:\n");
|
|
DataFlavor[] dfs = t.getTransferDataFlavors();
|
|
int ii;
|
|
for(ii = 0; ii < dfs.length; ++ii)
|
|
System.err.println("Supported:" + dfs[ii] + "\n");
|
|
dfs = HTMLTransferTest.HTMLFlavors;
|
|
for(ii = 0; ii < dfs.length; ++ii)
|
|
System.err.println("Accepted:" + dfs[ii] + "\n" );
|
|
}
|
|
}
|
|
System.err.println( "----------------------------------------------------------");
|
|
notifyTransferSuccess(bSuccess);
|
|
System.err.println( "============================================================");
|
|
++fi;
|
|
}
|
|
System.err.println("}CONSUMER: lost clipboard ownership");
|
|
}
|
|
|
|
|
|
void notifyTransferSuccess(boolean status) {
|
|
System.err.println(
|
|
"format "
|
|
+ (status
|
|
? "passed"
|
|
: "failed"
|
|
)
|
|
+ "!!!"
|
|
);
|
|
setClipboardContents(
|
|
new HTMLSelection(
|
|
HTMLTransferTest.SyncFlavor,
|
|
status
|
|
? S_PASSED
|
|
: S_FAILED
|
|
),
|
|
this
|
|
);
|
|
}
|
|
|
|
|
|
public static void main(String[] args) {
|
|
try {
|
|
System.err.println("{CONSUMER: start");
|
|
THTMLConsumer ic = new THTMLConsumer();
|
|
ic.setClipboardContents(
|
|
new HTMLSelection(
|
|
HTMLTransferTest.SyncFlavor,
|
|
S_BEGIN_ANSWER
|
|
),
|
|
ic
|
|
);
|
|
synchronized (LOCK) {
|
|
LOCK.wait();
|
|
}
|
|
System.err.println("}CONSUMER: start");
|
|
} catch (Throwable e) {
|
|
e.printStackTrace();
|
|
System.exit(HTMLTransferTest.CODE_FAILURE);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* A <code>Transferable</code> which implements the capability required
|
|
* to transfer an <code>HTML</code>.
|
|
*
|
|
* This <code>Transferable</code> properly supports
|
|
* <code>HTMLTransferTest.HTMLFlavors</code>.
|
|
* and all equivalent flavors.
|
|
* No other <code>DataFlavor</code>s are supported.
|
|
*
|
|
* @see java.awt.datatransfer.HTMLTransferTest.HTMLFlavors
|
|
*/
|
|
class HTMLSelection implements Transferable {
|
|
private DataFlavor m_flavor;
|
|
private Object m_data;
|
|
|
|
/**
|
|
* Creates a <code>Transferable</code> capable of transferring
|
|
* the specified <code>String</code>.
|
|
*/
|
|
public HTMLSelection(
|
|
DataFlavor flavor,
|
|
Object data
|
|
){
|
|
m_flavor = flavor;
|
|
m_data = data;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of flavors in which this <code>Transferable</code>
|
|
* can provide the data. <code>DataFlavor.stringFlavor</code>
|
|
* is properly supported.
|
|
* Support for <code>DataFlavor.plainTextFlavor</code> is
|
|
* <b>deprecated</b>.
|
|
*
|
|
* @return an array of length one, whose element is <code>DataFlavor.
|
|
* HTMLTransferTest.HTMLFlavors</code>
|
|
*/
|
|
public DataFlavor[] getTransferDataFlavors() {
|
|
// returning flavors itself would allow client code to modify
|
|
// our internal behavior
|
|
return new DataFlavor[]{ m_flavor } ;
|
|
}
|
|
|
|
/**
|
|
* Returns whether the requested flavor is supported by this
|
|
* <code>Transferable</code>.
|
|
*
|
|
* @param flavor the requested flavor for the data
|
|
* @return true if <code>flavor</code> is equal to
|
|
* <code>HTMLTransferTest.HTMLFlavors</code>;
|
|
* false if <code>flavor</code>
|
|
* is not one of the above flavors
|
|
* @throws NullPointerException if flavor is <code>null</code>
|
|
*/
|
|
public boolean isDataFlavorSupported(DataFlavor flavor) {
|
|
System.err.println("Have:" + flavor + " Can:" + m_flavor);
|
|
if(flavor.equals(m_flavor))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns the <code>Transferable</code>'s data in the requested
|
|
* <code>DataFlavor</code> if possible. If the desired flavor is
|
|
* <code>HTMLTransferTest.HTMLFlavors</code>, or an equivalent flavor,
|
|
* the <code>HTML</code> representing the selection is
|
|
* returned.
|
|
*
|
|
* @param flavor the requested flavor for the data
|
|
* @return the data in the requested flavor, as outlined above
|
|
* @throws UnsupportedFlavorException if the requested data flavor is
|
|
* not equivalent to <code>HTMLTransferTest.HTMLFlavors</code>
|
|
* @throws IOException if an IOException occurs while retrieving the data.
|
|
* By default, <code>HTMLSelection</code> never throws
|
|
* this exception, but a subclass may.
|
|
* @throws NullPointerException if flavor is <code>null</code>
|
|
*/
|
|
public Object getTransferData(DataFlavor flavor)
|
|
throws UnsupportedFlavorException, IOException
|
|
{
|
|
if (flavor.equals(m_flavor)) {
|
|
return (Object)m_data;
|
|
} else {
|
|
throw new UnsupportedFlavorException(flavor);
|
|
}
|
|
}
|
|
|
|
} // class HTMLSelection
|
|
|
|
|
|
/****************************************************
|
|
Standard Test Machinery
|
|
DO NOT modify anything below -- it's a standard
|
|
chunk of code whose purpose is to make user
|
|
interaction uniform, and thereby make it simpler
|
|
to read and understand someone else's test.
|
|
****************************************************/
|
|
class Sysout
|
|
{
|
|
private static TestDialog dialog;
|
|
|
|
public static void createDialogWithInstructions( String[] instructions )
|
|
{
|
|
dialog = new TestDialog( new Frame(), "Instructions" );
|
|
dialog.printInstructions( instructions );
|
|
dialog.show();
|
|
println( "Any messages for the tester will display here." );
|
|
}
|
|
|
|
public static void createDialog( )
|
|
{
|
|
dialog = new TestDialog( new Frame(), "Instructions" );
|
|
String[] defInstr = { "Instructions will appear here. ", "" } ;
|
|
dialog.printInstructions( defInstr );
|
|
dialog.show();
|
|
println( "Any messages for the tester will display here." );
|
|
}
|
|
|
|
|
|
public static void printInstructions( String[] instructions )
|
|
{
|
|
dialog.printInstructions( instructions );
|
|
}
|
|
|
|
|
|
public static void println( String messageIn )
|
|
{
|
|
dialog.displayMessage( messageIn );
|
|
}
|
|
|
|
}// Sysout class
|
|
|
|
class TestDialog extends Dialog
|
|
{
|
|
|
|
TextArea instructionsText;
|
|
TextArea messageText;
|
|
int maxStringLength = 80;
|
|
|
|
//DO NOT call this directly, go through Sysout
|
|
public TestDialog( Frame frame, String name )
|
|
{
|
|
super( frame, name );
|
|
int scrollBoth = TextArea.SCROLLBARS_BOTH;
|
|
instructionsText = new TextArea( "", 15, maxStringLength, scrollBoth );
|
|
add( "North", instructionsText );
|
|
|
|
messageText = new TextArea( "", 5, maxStringLength, scrollBoth );
|
|
add("South", messageText);
|
|
|
|
pack();
|
|
|
|
show();
|
|
}// TestDialog()
|
|
|
|
//DO NOT call this directly, go through Sysout
|
|
public void printInstructions( String[] instructions )
|
|
{
|
|
//Clear out any current instructions
|
|
instructionsText.setText( "" );
|
|
|
|
//Go down array of instruction strings
|
|
|
|
String printStr, remainingStr;
|
|
for( int i=0; i < instructions.length; i++ )
|
|
{
|
|
//chop up each into pieces maxSringLength long
|
|
remainingStr = instructions[ i ];
|
|
while( remainingStr.length() > 0 )
|
|
{
|
|
//if longer than max then chop off first max chars to print
|
|
if( remainingStr.length() >= maxStringLength )
|
|
{
|
|
//Try to chop on a word boundary
|
|
int posOfSpace = remainingStr.
|
|
lastIndexOf(' ', maxStringLength - 1);
|
|
|
|
if( posOfSpace <= 0 ) posOfSpace = maxStringLength - 1;
|
|
|
|
printStr = remainingStr.substring( 0, posOfSpace + 1 );
|
|
remainingStr = remainingStr.substring( posOfSpace + 1 );
|
|
}
|
|
//else just print
|
|
else
|
|
{
|
|
printStr = remainingStr;
|
|
remainingStr = "";
|
|
}
|
|
|
|
instructionsText.append( printStr + "\n" );
|
|
|
|
}// while
|
|
|
|
}// for
|
|
|
|
}//printInstructions()
|
|
|
|
//DO NOT call this directly, go through Sysout
|
|
public void displayMessage( String messageIn )
|
|
{
|
|
messageText.append( messageIn + "\n" );
|
|
}
|
|
|
|
}// TestDialog class
|