Skip to content

Instantly share code, notes, and snippets.

@ino76

ino76/Displej_projekt_.idea_libraries_src.xml

Created December 26, 2016 15:40
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ino76/303db9f46f9a437afdcd7ce95129aed5 to your computer and use it in GitHub Desktop.
Save ino76/303db9f46f9a437afdcd7ce95129aed5 to your computer and use it in GitHub Desktop.
Download ZIP
Last project in Java book from mr. Pecinovsky(Java 7: učebnice objektové architektury pro začátečníky). Its a digital display that emulates real blocks of segment display. Every number is represented by binary code where '1' means that segment is on and '0' that segment is off.
Raw
Displej_projekt_.idea_libraries_src.xml
<component name="libraryTable">
<library name="src">
<CLASSES />
<JAVADOC />
<SOURCES>
<root url="file://$PROJECT_DIR$/src" />
</SOURCES>
</library>
</component>
Raw
Displej_projekt_.idea_misc.xml
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ClientPropertiesManager">
<properties class="javax.swing.AbstractButton">
<property name="hideActionText" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JComponent">
<property name="html.disable" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JEditorPane">
<property name="JEditorPane.w3cLengthUnits" class="java.lang.Boolean" />
<property name="JEditorPane.honorDisplayProperties" class="java.lang.Boolean" />
<property name="charset" class="java.lang.String" />
</properties>
<properties class="javax.swing.JList">
<property name="List.isFileList" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JPasswordField">
<property name="JPasswordField.cutCopyAllowed" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JSlider">
<property name="Slider.paintThumbArrowShape" class="java.lang.Boolean" />
<property name="JSlider.isFilled" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JTable">
<property name="Table.isFileList" class="java.lang.Boolean" />
<property name="JTable.autoStartsEdit" class="java.lang.Boolean" />
<property name="terminateEditOnFocusLost" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JToolBar">
<property name="JToolBar.isRollover" class="java.lang.Boolean" />
</properties>
<properties class="javax.swing.JTree">
<property name="JTree.lineStyle" class="java.lang.String" />
</properties>
<properties class="javax.swing.text.JTextComponent">
<property name="caretAspectRatio" class="java.lang.Double" />
<property name="caretWidth" class="java.lang.Integer" />
</properties>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="1.8" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>
Raw
Displej_projekt_.idea_modules.xml
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/Displej_projekt.iml" filepath="$PROJECT_DIR$/Displej_projekt.iml" />
</modules>
</component>
</project>
Raw
Displej_projekt_Displej_projekt.iml
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" name="src" level="project" />
</component>
</module>
Raw
Displej_projekt_segmantovy_displej_-_zaverecny_projekt.properties
path.variable.kotlin_bundled=C\:\\Program Files (x86)\\JetBrains\\IntelliJ IDEA Community Edition 2016.2.5\\plugins\\Kotlin\\kotlinc
path.variable.maven_repository=C\:\\Users\\cechd\\.m2\\repository
jdk.home.1.8=C\:/Program Files/Java/jdk1.8.0_91
javac2.instrumentation.includeJavaRuntime=false
Raw
Displej_projekt_segmantovy_displej_-_zaverecny_projekt.xml
<?xml version="1.0" encoding="UTF-8"?>
<project name="segmantovy_displej_-_zaverecny_projekt" default="all">
<property file="segmantovy_displej_-_zaverecny_projekt.properties"/>
<!-- Uncomment the following property if no tests compilation is needed -->
<!--
<property name="skip.tests" value="true"/>
-->
<!-- Compiler options -->
<property name="compiler.debug" value="on"/>
<property name="compiler.generate.no.warnings" value="off"/>
<property name="compiler.args" value=""/>
<property name="compiler.max.memory" value="700m"/>
<patternset id="ignored.files">
<exclude name="**/*.hprof/**"/>
<exclude name="**/*.pyc/**"/>
<exclude name="**/*.pyo/**"/>
<exclude name="**/*.rbc/**"/>
<exclude name="**/*.yarb/**"/>
<exclude name="**/*~/**"/>
<exclude name="**/.DS_Store/**"/>
<exclude name="**/.git/**"/>
<exclude name="**/.hg/**"/>
<exclude name="**/.svn/**"/>
<exclude name="**/CVS/**"/>
<exclude name="**/RCS/**"/>
<exclude name="**/SCCS/**"/>
<exclude name="**/__pycache__/**"/>
<exclude name="**/_svn/**"/>
<exclude name="**/rcs/**"/>
<exclude name="**/vssver.scc/**"/>
<exclude name="**/vssver2.scc/**"/>
</patternset>
<patternset id="library.patterns">
<include name="*.war"/>
<include name="*.swc"/>
<include name="*.apk"/>
<include name="*.zip"/>
<include name="*.ear"/>
<include name="*.egg"/>
<include name="*.ane"/>
<include name="*.jar"/>
</patternset>
<patternset id="compiler.resources">
<exclude name="**/?*.java"/>
<exclude name="**/?*.form"/>
<exclude name="**/?*.class"/>
<exclude name="**/?*.groovy"/>
<exclude name="**/?*.scala"/>
<exclude name="**/?*.flex"/>
<exclude name="**/?*.kt"/>
<exclude name="**/?*.clj"/>
<exclude name="**/?*.aj"/>
</patternset>
<!-- JDK definitions -->
<property name="jdk.bin.1.8" value="${jdk.home.1.8}/bin"/>
<path id="jdk.classpath.1.8">
<fileset dir="${jdk.home.1.8}">
<include name="jre/lib/charsets.jar"/>
<include name="jre/lib/deploy.jar"/>
<include name="jre/lib/ext/access-bridge-64.jar"/>
<include name="jre/lib/ext/cldrdata.jar"/>
<include name="jre/lib/ext/dnsns.jar"/>
<include name="jre/lib/ext/jaccess.jar"/>
<include name="jre/lib/ext/jfxrt.jar"/>
<include name="jre/lib/ext/localedata.jar"/>
<include name="jre/lib/ext/nashorn.jar"/>
<include name="jre/lib/ext/sunec.jar"/>
<include name="jre/lib/ext/sunjce_provider.jar"/>
<include name="jre/lib/ext/sunmscapi.jar"/>
<include name="jre/lib/ext/sunpkcs11.jar"/>
<include name="jre/lib/ext/zipfs.jar"/>
<include name="jre/lib/javaws.jar"/>
<include name="jre/lib/jce.jar"/>
<include name="jre/lib/jfr.jar"/>
<include name="jre/lib/jfxswt.jar"/>
<include name="jre/lib/jsse.jar"/>
<include name="jre/lib/management-agent.jar"/>
<include name="jre/lib/plugin.jar"/>
<include name="jre/lib/resources.jar"/>
<include name="jre/lib/rt.jar"/>
</fileset>
</path>
<property name="project.jdk.home" value="${jdk.home.1.8}"/>
<property name="project.jdk.bin" value="${jdk.bin.1.8}"/>
<property name="project.jdk.classpath" value="jdk.classpath.1.8"/>
<!-- Register Custom Compiler Taskdefs -->
<property name="javac2.home" value="${idea.home}/lib"/>
<path id="javac2.classpath">
<pathelement location="${javac2.home}/javac2.jar"/>
<pathelement location="${javac2.home}/jdom.jar"/>
<pathelement location="${javac2.home}/asm-all.jar"/>
<pathelement location="${javac2.home}/jgoodies-forms.jar"/>
</path>
<target name="register.custom.compilers">
<taskdef name="javac2" classname="com.intellij.ant.Javac2" classpathref="javac2.classpath"/>
<taskdef name="instrumentIdeaExtensions" classname="com.intellij.ant.InstrumentIdeaExtensions" classpathref="javac2.classpath"/>
</target>
<!-- Modules -->
<!-- Module Displej_projekt -->
<dirname property="module.displej_projekt.basedir" file="${ant.file}"/>
<property name="module.jdk.home.displej_projekt" value="${project.jdk.home}"/>
<property name="module.jdk.bin.displej_projekt" value="${project.jdk.bin}"/>
<property name="module.jdk.classpath.displej_projekt" value="${project.jdk.classpath}"/>
<property name="compiler.args.displej_projekt" value="-encoding UTF-8 -source 8 -target 8 ${compiler.args}"/>
<property name="displej_projekt.output.dir" value="${module.displej_projekt.basedir}/out/production/Displej_projekt"/>
<property name="displej_projekt.testoutput.dir" value="${module.displej_projekt.basedir}/out/test/Displej_projekt"/>
<path id="displej_projekt.module.bootclasspath">
<!-- Paths to be included in compilation bootclasspath -->
</path>
<path id="displej_projekt.module.production.classpath">
<path refid="${module.jdk.classpath.displej_projekt}"/>
</path>
<path id="displej_projekt.runtime.production.module.classpath">
<pathelement location="${displej_projekt.output.dir}"/>
</path>
<path id="displej_projekt.module.classpath">
<path refid="${module.jdk.classpath.displej_projekt}"/>
<pathelement location="${displej_projekt.output.dir}"/>
</path>
<path id="displej_projekt.runtime.module.classpath">
<pathelement location="${displej_projekt.testoutput.dir}"/>
<pathelement location="${displej_projekt.output.dir}"/>
</path>
<patternset id="excluded.from.module.displej_projekt">
<patternset refid="ignored.files"/>
</patternset>
<patternset id="excluded.from.compilation.displej_projekt">
<patternset refid="excluded.from.module.displej_projekt"/>
</patternset>
<path id="displej_projekt.module.sourcepath">
<dirset dir="${module.displej_projekt.basedir}">
<include name="src"/>
</dirset>
</path>
<target name="compile.module.displej_projekt" depends="compile.module.displej_projekt.production,compile.module.displej_projekt.tests" description="Compile module Displej_projekt"/>
<target name="compile.module.displej_projekt.production" depends="register.custom.compilers" description="Compile module Displej_projekt; production classes">
<mkdir dir="${displej_projekt.output.dir}"/>
<javac2 destdir="${displej_projekt.output.dir}" debug="${compiler.debug}" nowarn="${compiler.generate.no.warnings}" memorymaximumsize="${compiler.max.memory}" fork="true" executable="${module.jdk.bin.displej_projekt}/javac">
<compilerarg line="${compiler.args.displej_projekt}"/>
<bootclasspath refid="displej_projekt.module.bootclasspath"/>
<classpath refid="displej_projekt.module.production.classpath"/>
<src refid="displej_projekt.module.sourcepath"/>
<patternset refid="excluded.from.compilation.displej_projekt"/>
</javac2>
<copy todir="${displej_projekt.output.dir}">
<fileset dir="${module.displej_projekt.basedir}/src">
<patternset refid="compiler.resources"/>
<type type="file"/>
</fileset>
</copy>
</target>
<target name="compile.module.displej_projekt.tests" depends="register.custom.compilers,compile.module.displej_projekt.production" description="compile module Displej_projekt; test classes" unless="skip.tests"/>
<target name="clean.module.displej_projekt" description="cleanup module">
<delete dir="${displej_projekt.output.dir}"/>
<delete dir="${displej_projekt.testoutput.dir}"/>
</target>
<target name="init" description="Build initialization">
<!-- Perform any build initialization in this target -->
</target>
<target name="clean" depends="clean.module.displej_projekt" description="cleanup all"/>
<target name="build.modules" depends="init, clean, compile.module.displej_projekt" description="build all modules"/>
<target name="all" depends="build.modules" description="build all"/>
</project>
Raw
Displej_projekt_src_knihovna_AHybaci.java
package knihovna;
/*******************************************************************************
* Trida AHybaci je spolecnou rodicovskou tridou trid implementujicich
* rozhrani IHybaci.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public abstract class AHybaci extends APosuvny
implements IHybaci, IPrizpusobivy
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private int sirka; //sirka v bodech
private int vyska; //Vyska v bodech
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori na zadanych souradnicich
* instanci sirokou 100 bodu, vysokou 150 bodu
* s kmenem zabirajicim 1/3 vyska a 1/10 sirky stromu.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka >= 0
* @param vyska Vyska vytvarene instance, vyska >= 0
*/
public AHybaci( int x, int y, int sirka, int vyska )
{
super( x, y );
//Test platnosti parametru
if( (sirka<0) || (vyska<0) ) {
throw new IllegalArgumentException(
"\nParametry nemaji povolene hodnoty: sirka="
+ sirka + ", vyska=" + vyska );
}
//Parametry akceptovany --> muzeme tvorit
this.sirka = sirka;
this.vyska = vyska;
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Vrati sirku instance.
*
* @return sirka instance v bodech
*/
public int getSirka()
{
return sirka;
}
/***************************************************************************
* Vrati vysku instance.
*
* @return vyska instance v bodech
*/
public int getVyska()
{
return vyska;
}
/***************************************************************************
* Nastavi novy vodorovny rozmer instance.
*
* @param sirka Nove nastavovana sirka; sirka>=0
*/
public void setSirka(int sirka)
{
setRozmer(sirka, getVyska());
}
/***************************************************************************
* Nastavi novy svisly rozmer instance.
*
* @param vyska Nove nastavovana vyska; vyska>=0
*/
public void setVyska(int vyska)
{
setRozmer(getSirka(), vyska);
}
/***************************************************************************
* Vrati instanci tridy Rozmer s rozmery instance.
*
* @return Rozmer s rozmery instance.
*/
public Rozmer getRozmer()
{
return new Rozmer( getSirka(), getVyska() );
}
/***************************************************************************
* Nastavi novy "ctvercovy" rozmer instance -
* na zadany rozmer se nastavi vyska i sirka.
*
* @param rozmer Nove nastavovany rozmer v obou smerech; rozmer>0
*/
public void setRozmer(int rozmer)
{
setRozmer( rozmer, rozmer );
}
/***************************************************************************
* Nastavi nove rozmery instance.
*
* @param sirka Nove nastavovana sirka; sirka>=0
* @param vyska Nove nastavovana vyska; vyska>=0
*/
public void setRozmer(int sirka, int vyska)
{
if( (sirka != this.sirka) || (vyska != this.vyska) ) {
if( (sirka < 0) || (vyska < 0) ) {
throw new IllegalArgumentException(
"Rozmery musi byt nezaporne: sirka=" + sirka +
", vyska=" + vyska );
}
this.sirka = sirka;
this.vyska = vyska;
SP.prekresli();
}
}
/***************************************************************************
* Nastavi nove rozmery instance.
*
* @param rozmer Nove nastavovany rozmer.
*/
public void setRozmer(Rozmer rozmer)
{
setRozmer( rozmer.sirka, rozmer.vyska );
}
/***************************************************************************
* Vrati instanci tridy Oblast s informacemi o pozici a rozmerech instance.
*
* @return Oblast s informacemi o pozici a rozmere instance.
*/
public Oblast getOblast()
{
return new Oblast( getX(), getY(), getSirka(), getVyska() );
}
/***************************************************************************
* Nastavi novou polohu a rozmery instance.
*
* @param o Nove nastavovana oblast zaujimana instanci.
*/
public void setOblast(Oblast o)
{
SP.nekresli(); {
setPozice( o.x, o.y );
setRozmer( o.sirka, o.vyska );
} SP.vratKresli();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
public void krokZmenen( int stary, int novy )
{
double pomer = (double)novy / stary;
SP.nekresli(); {
setPozice( (int)Math.round(pomer*getX()),
(int)Math.round(pomer*getY()) );
setRozmer( (int)Math.round(pomer*getSirka()),
(int)Math.round(pomer*getVyska()) );
} SP.vratKresli();
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Vraci textovou reprezentaci dane instance
* pouzivanou predevsim k ladicim ucelum.
*
* @return Nazev instance nasledovnay jejimi souradnicemi.
*/
@Override
public String toString()
{
return super.toString() +
", sirka=" + getSirka() + ", vyska=" + getVyska();
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_APosuvny.java
package knihovna;
/*******************************************************************************
* Trida {@code APosuvny} je spolecnou rodicovskou tridou trid implementujicich
* rozhrani {@link IPosuvny}.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public abstract class APosuvny implements IPosuvny
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Instance tridy {@link SpravcePlatna} spravujici platno,
* na ktere se vsechny tvary kresli. */
protected static final SpravcePlatna SP = SpravcePlatna.getInstance(false);
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Celkovy pocet vytvorenych instanci. */
private static int pocet = 0;
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Rodne cislo instance = jako kolikata byla vytvorena. */
protected final int poradi = ++pocet;
//== PROMENNE ATRIBUTY INSTANCI ================================================
/** Nazev instance sestavajici implicitne z nazvu tridy a poradi instance */
protected String nazev;
/** Bodova x-ova souradnice instance. */
private int xPos;
/** Bodova y-ova souradnice instance. */
private int yPos;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori na zadanych souradnicich
* instanci sirokou 100 bodu, vysokou 150 bodu
* s kmenem zabirajicim 1/3 vyska a 1/10 sirky stromu.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
*/
public APosuvny( int x, int y )
{
//Test platnosti parametru
if( (x<0) || (y<0) ) {
throw new IllegalArgumentException(
"\nParametry nemaji povolene hodnoty: x=" + x + ", y=" + y );
}
//Parametry akceptovany --> muzeme tvorit
xPos = x;
yPos = y;
nazev = this.getClass().getSimpleName() + "_" + pocet;
}
//== ABSTRAKTNI METODY =========================================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno
*/
abstract public void nakresli( Kreslitko kreslitko );
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Vrati nazev instance, tj. nazev jeji tridy nasledovany poradim.
*
* @return Retezec s nazvem instance.
*/
public String getNazev()
{
return nazev;
}
/***************************************************************************
* Nastavi novy nazev instance.
*
* @param nazev Retezec s novym nazvem instance.
*/
public void setNazev(String nazev)
{
this.nazev = nazev;
}
/***************************************************************************
* Vrati x-ovou souradnici pozice instance.
*
* @return x-ova souradnice.
*/
public int getX()
{
return xPos;
}
/***************************************************************************
* Vrati y-ovou souradnici pozice instance.
*
* @return y-ova souradnice.
*/
public int getY()
{
return yPos;
}
/***************************************************************************
* Vrati instanci tridy Pozice s pozici instance.
*
* @return Pozice s pozici instance.
*/
public Pozice getPozice()
{
return new Pozice( getX(), getY() );
}
/***************************************************************************
* Nastavi novou pozici instance.
*
* @param x Nova x-ova pozice instance
* @param y Nova y-ova pozice instance
*/
public void setPozice(int x, int y)
{
if((x != xPos) || (y != yPos)) {
xPos = x;
yPos = y;
SP.prekresli();
}
}
/***************************************************************************
* Nastavi novou pozici instance.
*
* @param pozice Nova pozice instance
*/
public void setPozice(Pozice pozice)
{
setPozice( pozice.x, pozice.y );
}
/***************************************************************************
* Nastavi novou vodorovnou pozici instance.
*
* @param x Nova x-ova pozice instance
*/
public void setX(int x)
{
setPozice( x, getY());
}
/***************************************************************************
* Nastavi novou svislou pozici instance.
*
* @param y Nova y-ova pozice instance
*/
public void setY(int y)
{
setPozice( getX(), y);
}
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
/***************************************************************************
* Vraci textovou reprezentaci dane instance
* pouzivanou predevsim k ladicim ucelum.
*
* @return Nazev instance nasledovnay jejimi souradnicemi.
*/
@Override
public String toString()
{
return nazev + ": x=" + getX() + ", y=" + getY();
}
/***************************************************************************
* Prihlasi instanci u spravce platna do jeho spravy
* a tim zaridi jeji zobrazeni.
*/
public void zobraz()
{
SP.pridej( this );
}
/***************************************************************************
* Odstrani obraz sve instance z platna.
*/
public void smaz()
{
SP.odstran( this );
}
/***************************************************************************
* Presune instanci o zadany pocet bodu vpravo,
* pri zaporne hodnote parametru vlevo.
*
* @param vzdalenost Vzdalenost, o kterou se instance presune.
*/
public void posunVpravo(int vzdalenost)
{
setPozice( getX()+vzdalenost, getY() );
}
/***************************************************************************
* Presune instanci o krok bodu vpravo.
*/
public void posunVpravo()
{
posunVpravo( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu vlevo.
*/
public void posunVlevo()
{
posunVpravo( -SP.getKrok() );
}
/***************************************************************************
* Presune instanci o zadany pocet bodu dolu,
* pri zaporne hodnote parametru nahoru.
*
* @param vzdalenost Pocet bodu, o ktere se instance presune.
*/
public void posunDolu(int vzdalenost)
{
setPozice( getX(), getY()+vzdalenost );
}
/***************************************************************************
* Presune instanci o krok bodu dolu.
*/
public void posunDolu()
{
posunDolu( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu nahoru.
*/
public void posunVzhuru()
{
posunDolu( -SP.getKrok() );
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Barva.java
package knihovna;
import java.awt.*;
import java.text.Collator;
import java.util.*;
import java.util.List;
/*******************************************************************************
* Trida {@code Barva} definuje skupinu zakladnich barev pro pouziti
* pri kresleni tvaru pred zavedenim balicku.
* Neni definovana jako vyctovy typ, aby si uzivatel mohl libovolne pridavat
* vlastni barvy.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Barva
{
/** Pocet pojmenovanych barev se pri konstrukci nasledujicich instanci
* nacita, a proto musi byt deklarovan pred nimi. */
private static int pocet = 0;
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Mapa vsech doposud vytvorenych barev klicovana jejich nazvy. */
private static final Map<String,Barva> NAZVY =
new LinkedHashMap<String,Barva>();
/** Mapa vsech doposud vytvorenych barev klicovana jejich nazvy
* s odstranenou diakritikou. */
private static final Map<String,Barva> NAZVY_BHC =
new LinkedHashMap<String,Barva>();
private static final Map<Color,Barva> COLOR =
new LinkedHashMap<Color,Barva>();
private static final List<Barva> BARVY = new ArrayList<Barva>( 32 );
/** Cerna = RGBA( 0, 0, 0, 255); */ public static final Barva
CERNA = new Barva( Color.BLACK, "cerna" );
/** Modra = RGBA( 0, 0, 255, 255); */ public static final Barva
MODRA = new Barva( Color.BLUE, "modra" );
/** Cervena = RGBA( 255, 0, 0, 255); */ public static final Barva
CERVENA = new Barva( Color.RED, "cervena" );
/** Fialova = RGBA( 255, 0, 255, 255); */ public static final Barva
FIALOVA = new Barva( Color.MAGENTA, "fialova" );
/** Zelena = RGBA( 0, 255, 0, 255); */ public static final Barva
ZELENA = new Barva( Color.GREEN, "zelena" );
/** Azurova = RGBA( 0, 255, 255, 255); <br> Lze pro ni pouzit i
* textovy nazev "blankytna". */ public static final Barva
AZUROVA = new Barva( Color.CYAN, "azurova" );
/** Zluta = RGBA( 255, 255, 0, 255); */ public static final Barva
ZLUTA = new Barva( Color.YELLOW, "zluta" );
/** Bila = RGBA( 255, 255, 255, 255); */ public static final Barva
BILA = new Barva( Color.WHITE, "bila" );
/** Svetleseda = RGBA( 192,192,192,255 ); */public static final Barva
SVETLESEDA = new Barva( Color.LIGHT_GRAY, "svetleseda"); //128 = 0x80
/** Seda = RGBA( 128, 128, 128, 255); */ public static final Barva
SEDA = new Barva( Color.GRAY, "seda" );
/** Tmavoseda = RGBA( 64, 64, 64, 255);*/public static final Barva
TMAVOSEDA = new Barva( Color.DARK_GRAY, "tmavoseda" ); //64 = 0x40
/** Cerna = RGBA( 255, 175, 175, 255); */ public static final Barva
RUZOVA = new Barva( Color.PINK, "ruzova" ); //175 = 0xAF
/** Oranzova = RGBA( 255, 200, 0, 255); */ public static final Barva
ORANZOVA= new Barva( Color.ORANGE, "oranzova");
//=== Barvy bez ekvivalentnich konstant in java.awt.Color
/** Stribrna = RGBA( 216, 216, 216, 255); */public static final Barva
STRIBRNA = new Barva( 0xD8, 0xD8, 0xD8, 0xFF, "stribrna" );
/** Zlata = RGBA( 255, 224, 0, 255); */ public static final Barva
ZLATA = new Barva( 0xFF, 0xE0, 0x00, 0xFF, "zlata" );
/** Cihlova = RGBA( 255, 102, 0, 255); */ public static final Barva
CIHLOVA = new Barva( 0xFF, 0x66, 0, 0xFF, "cihlova" );
/** Hneda = RGBA( 153, 51, 0, 255); */ public static final Barva
HNEDA = new Barva( 0x99, 0x33, 0x00, 0xFF, "hneda" );
/** Kremova = RGBA( 255, 255, 204, 255); */ public static final Barva
KREMOVA = new Barva( 0xFF, 0xFF, 0xCC, 0xFF,"kremova" );
/** Khaki = RGBA( 153, 153, 0, 255); */ public static final Barva
KHAKI = new Barva( 0x99, 0x99, 0x00, 0xFF, "khaki" );
/** Ocelova = RGBA( 0, 153, 204, 255); */ public static final Barva
OCELOVA = new Barva( 0x00, 0x99, 0xCC, 0xFF,"ocelova" );
/** Okrova = RGBA( 255, 153, 0, 255); */ public static final Barva
OKROVA = new Barva( 0xFF, 0x99, 0x00, 0xFF, "okrova" );
//=== Prusvitne barvy
/** Mlecna=RGBA( 255, 255, 255, 128 ) - polovicne prusvitna bila. */
public static final Barva
MLECNA = new Barva( 0xFF, 0xFF, 0xFF, 0x80, "mlecna");
/** Kourova = RGBA( 128, 128, 128, 128 ) - polovicne prusvitna seda. */
public static final Barva
KOUROVA = new Barva( 0x80, 0x80, 0x80, 0x80, "kourova");
/** Zadna = RGBA( 0,0,0,0) - PRUHLEDNA! */ public static final Barva
ZADNA = new Barva( 0, 0, 0, 0, "zadna");
//Alternativni nazvy nekterych barev
static
{
AZUROVA .pridejNazev( "blankytna" );
}
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Priznak velikosti pismen, jimiz se vypisuji nazvy barev. */
private static boolean velkymi = false;
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
private final String nazev; //Nazev barvy zadavany konstruktoru
private final Color color; //Barva ze standardni knihovny
private final int index = pocet++;
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
/***************************************************************************
* Vrati vektor doposud definovanych barev.
*
* @return Vektor doposud definovanych barev
*/
public static Barva[] getZnameBarvy()
{
return BARVY.toArray( new Barva[BARVY.size()] );
}
/***************************************************************************
* Vrati vektor retezcu s dopsud definovanymi nazvy barev.
* Nazvu barev je vice nez definovanych barev, protoze barvy mohou mit
* vice nazvu (a nektere jich opravdu maji nekolik).
*
* @return Vektor retezcu s dopsud definovanymi nazvy barev
*/
public static String[] getZnameNazvy()
{
String[] nazvy = NAZVY.keySet().toArray( new String[ NAZVY.size() ] );
Arrays.sort(nazvy, Collator.getInstance());
if( velkymi ) {
for (int i = 0; i < nazvy.length; i++) {
nazvy[i] = nazvy[i].toUpperCase();
}
}
return nazvy;
}
/***************************************************************************
* Nastavi, zda se budou nazvy barev vypisovat velkymi pismeny.
*
* @param velkymi {@code true} maji-li se nazvy vypisovat velkymi pismeny,
* jinak {@code false}
* @return Puvdoni nastaveni
*/
public static boolean setVelkymi( boolean velkymi )
{
boolean puvodni = Barva.velkymi;
Barva.velkymi = velkymi;
return puvodni;
}
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
/***************************************************************************
* Otevre dialogove okno, v nemz vypise vsechny doposud definovane
* nazvy barev. Jmena jsou lexikograficky serazena.
*/
public static void vypisZnameNazvy()
{
final int MAX_V_RADKU = 64;
String[] nazvy = getZnameNazvy();
StringBuilder sb = new StringBuilder();
for( int i=0, vRadku=0; i < nazvy.length; i++ ) {
String text = nazvy[i];
int textLength = text.length();
if( (vRadku + textLength) >= MAX_V_RADKU ) {
sb.append('\n');
vRadku = 0;
}
sb.append(text);
vRadku += textLength + 2;
if( i < nazvy.length ) {
sb.append(", ");
}
}
// System.out.println("Barvy:\n" + sb);
IO.zprava(sb);
}
/***************************************************************************
* Vrati kolekci doposud definovanych barev.
*
* @return Vektor doposud definovanych barev
*/
public static Collection<Barva> znameBarvy()
{
return Collections.unmodifiableList( BARVY );
}
/***************************************************************************
* Vrati kolekci retezcu doposud definovanych nazvu barev.
* Nazvu barev je vice nez definovanych barev, protoze barvy mohou mit
* vice nazvu (a nektere jich opravdu maji nekolik).
*
* @return Vektor retezcu s dopsud definovanymi nazvy barev
*/
public static Collection<String> znameNazvy()
{
return Arrays.asList( getZnameNazvy() );
}
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori instanci barvy se zadanou velikosti barevnych slozek
* a hladinou pruhlednosti nastavovanou v kanale alfa
* a se zadanym ceskym nazvem a nazvem bez diakritiky.
*
* @param red Velikost cervene slozky
* @param green Velikost zelene slozky
* @param blue Velikost modre slozky
* @param alpha Hladina pruhlednosti: 0=pruhledna, 255=nepruhledna
* @param nazev Nazev vytvorene barvy
* @param nazevBHC Nazev bez hacku a carek
*/
private Barva( int red, int green, int blue, int alpha, String nazev )
{
this( new Color(red, green, blue, alpha), nazev );
}
/***************************************************************************
* Vytvori barvu ekvivalentni zadane instanci tridy
* {@link java.awt.Color} se zadanym ceskym nazvem.
*
* @param c Instance tridy {@link java.awt.Color} pozadovane barvy
* @param nazev Nazev vytvarene barvy; {@code null} oznaucje,
* ze se ma pro barvu vytvorit genericky nazev
*/
private Barva( Color c, String nazev )
{
this.color = c;
this.nazev = nazev.toLowerCase();
if( NAZVY.containsKey( nazev ) ||
COLOR.containsKey( c ) )
{
throw new IllegalArgumentException(
"\nInterni chyba - barva " + getNazev() + " a/nebo " +
getCharakteristikaDec() + " jiz existuji" );
}
NAZVY.put( nazev, this );
COLOR.put( color, this );
BARVY.add( this );
pridejNazevBezDiakritiky();
}
// if( (nazev == "") || (nazev == null) )
// throw new IllegalArgumentException(
// "Nazev barvy musi byt zadan" );
// nazev = nazev.toLowerCase();
// color = new Color( red, green, blue, alpha );
// if( NAZVY.containsKey( nazev ) ||
// COLOR.containsKey( color ) )
// {
// throw new IllegalArgumentException(
// "\nBarvu nelze vytvorit - barva " + getCharakteristikaDec() +
// " jiz existuje" );
// }
// BARVY.add( index, this );
// this.nazev = nazev;
// NAZVY.put( nazev, this );
// COLOR.put( color, this );
// String bhc = odhackuj( nazev );
// if( ! nazev.equals(bhc) )
// NAZVY.put( bhc, this );
// }
/***************************************************************************
* Prevede nazev barvy na prislusny objekt typu Barva.
*
* @param nazevBarvy Nazev pozadovane barvy -- seznam znamych nazvu
* je mozno ziskat zavolanim metody getZnameNazvy()
*
* @return Instance tridy Barva reprezentujici zadanou barvu
*
* @throws IllegalArgumentException neni-li barva (nazev) mezi znamymi
*/
public static Barva getBarva( String nazevBarvy )
{
Barva barva = NAZVY.get( nazevBarvy.toLowerCase() );
if( barva != null ) {
return barva;
}
else {
throw new IllegalArgumentException("Takto pojmenovanou barvu neznam.");
}
}
/***************************************************************************
* Vytvori instanci barvy se zadanou velikosti barevnych slozeka.
*
* @param red Velikost cervene slozky
* @param green Velikost zelene slozky
* @param blue Velikost modre slozky
* @return Barva se zadanymi velikostmi jednotlivych slozek
*/
public static Barva getBarva( int red, int green, int blue )
{
return getBarva( red, green, blue, 0xFF );
}
/***************************************************************************
* Vytvori instanci nepojmenovane barvy se zadanou velikosti barevnych
* slozeka hladinou pruhlednosti nastavovanou v kanale alfa.
*
* @param red Velikost cervene slozky
* @param green Velikost zelene slozky
* @param blue Velikost modre slozky
* @param alpha Hladina pruhlednosti: 0=pruhledna, 255=nepruhledna
* @return Barva se zadanymi velikostmi jednotlivych slozek
*/
public static Barva getBarva( int red, int green, int blue, int alpha )
{
Color color = new Color( red, green, blue, alpha );
Barva barva = COLOR.get( color );
if( barva != null ) {
return barva;
}
String nazev = "Barva(r=" + red + ",g=" + green +
",b=" + blue + ",a=" + alpha + ")" ;
return getBarva( red, green, blue, alpha, nazev );
}
/***************************************************************************
* Existuje-li zadana barva mezi znamymi, vrati ji; v opacnem pripade
* vytvori novou barvu se zadanymi parametry a vrati odkaz na ni.
*
* @param red Velikost cervene slozky
* @param green Velikost zelene slozky
* @param blue Velikost modre slozky
* @param nazev Nazev vytvorene barvy
*
* @return Barva se zadanym nazvem a velikostmi jednotlivych slozek
* @throws IllegalArgumentException ma-li nektere ze znamych barev nektery
* ze zadanych nazvu a pritom ma jine nastaveni barevnych slozek
* nebo ma jiny druhy nazev.
*/
public static Barva getBarva( int red, int green, int blue, String nazev )
{
return getBarva( red, green, blue, 0xFF, nazev );
}
/***************************************************************************
* Existuje-li zadana barva mezi znamymi, vrati ji; v opacnem pripade
* vytvori novou barvu se zadanymi parametry a vrati odkaz na ni.
*
* @param red Velikost cervene slozky
* @param green Velikost zelene slozky
* @param blue Velikost modre slozky
* @param alpha Hladina pruhlednosti: 0=pruhledna, 255=nepruhledna
* @param nazev Nazev vytvorene barvy
*
* @return Instance tridy Barva reprezentujici zadanou barvu.
*
* @throws IllegalArgumentException ma-li nektere ze znamych barev nektery
* ze zadanych nazvu a pritom ma jine nastaveni barevnych slozek
* nebo ma jiny druhy nazev.
*/
public static Barva getBarva( int red, int green, int blue, int alpha,
String nazev )
{
nazev = nazev.trim().toLowerCase();
if( (nazev == null) || nazev.equals("") ) {
throw new IllegalArgumentException(
"Barva musi mit zadan neprazdny nazev" );
}
Color color = new Color( red, green, blue, alpha );
Barva barvaN = NAZVY.get( nazev );
Barva barvaC = COLOR.get( color );
if( (barvaN != null) && (barvaN == barvaC) ) {
//Je pozadovana jiz existujici barva
return barvaN;
}
if( (barvaN == null) && (barvaC == null) ) {
//Je pozadovana dosud neexistujici barva
return new Barva(red, green, blue, alpha, nazev);
}
//Zjistime, s kterou existujici barvou pozadavky koliduji
Barva b = (barvaC != null) ? barvaC : barvaN;
Color c = b.color;
throw new IllegalArgumentException(
"\nZadane parametry barvy koliduji s parametry existujici barvy "+
"[existujici \u00d7 zadana]:" +
"\nnazev: " + b.getNazev() + " \u00d7 " + nazev +
"\ncervena slozka: " + c.getRed() + " \u00d7 " + red +
"\nzelena slozka: " + c.getGreen() + " \u00d7 " + green +
"\nmodra slozka: " + c.getBlue() + " \u00d7 " + blue +
"\npruhlednost: " + c.getAlpha() + " \u00d7 " + alpha );
}
//== NESOUKROME METODY INSTANCI ================================================
/***************************************************************************
* Prevede nami pouzivanou barvu na typ pouzivany kreslitkem.
*
* @return Instance tridy Color reprezentujici zadanou barvu
*/
public Color getColor()
{
return color;
}
/***************************************************************************
* Prevede nami pouzivanou barvu na typ pouzivany kreslitkem.
*
* @return Instance tridy Color reprezentujici zadanou barvu
*/
public String getCharakteristikaDec()
{
return String.format( "%s(dec:R=%d,G=%d,B=%d,A=%d)", nazev,
color.getRed(), color.getGreen(), color.getBlue(),
color.getAlpha());
}
/***************************************************************************
* Prevede nami pouzivanou barvu na typ pouzivany kreslitkem.
*
* @return Instance tridy Color reprezentujici zadanou barvu
*/
public String getCharakteristikaHex()
{
return String.format( "%s(hex:R=%02X,G=%02X,B=%02X,A=%02X)", nazev,
color.getRed(), color.getGreen(), color.getBlue(),
color.getAlpha());
}
/***************************************************************************
* Vrati nazev barvy.
*
* @return Retezec definujici zadanou barvu.
*/
public String getNazev()
{
return (velkymi ? nazev.toUpperCase() : nazev);
}
/***************************************************************************
* Vrati vektor nazvu dane barvy.
*
* @return Vektor navzu barvy
*/
public String[] getNazvy()
{
Collection<String> nazvy = nazvy();
return nazvy.toArray(new String[nazvy.size()]);
}
/***************************************************************************
* Vrati kolekci nazvu dane barvy.
*
* @return Kolekce navzu barvy
*/
public Collection<String> nazvy()
{
Collection<String> nazvy = new ArrayList<String>();
for( Map.Entry<String, Barva> entry : NAZVY.entrySet() ) {
if(entry.getValue() == this) {
nazvy.add( (velkymi ? entry.getKey().toUpperCase()
: entry.getKey() ) );
}
}
return nazvy;
}
/***************************************************************************
* Prida barve dalsi nazev - prezdivku.
*
* @param dalsiNazev Pridavany nazev, ktery se musi lisit od vsech
* doposud zavedenych nazvu, jejichz seznam lze ziskat
* zavolanim metody {@link #getZnameNazvy()}
* @throws IllegalArgumentException je-li zadany nazev jiz pouzit
*/
public void pridejNazev( String dalsiNazev ) {
dalsiNazev = dalsiNazev.toLowerCase();
Barva b = barvaSNazvem( dalsiNazev );
if( b == null ) {
NAZVY.put(dalsiNazev, this);
}
else {
throw new IllegalArgumentException("\nJmeno musi byt jedinecne. " +
"Barva s nazvem <<" + dalsiNazev + ">> je jiz definovana.");
}
}
/***************************************************************************
* Vrati nazev barvy.
*
* @return Nazev barvy
*/
@Override
public String toString()
{
return nazev;
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
/***************************************************************************
* Vrati barvu s danym nazvem pricem je schopen ignorovat diakritiku.
*/
private static Barva barvaSNazvem( String nazev ) {
nazev = nazev.toLowerCase();
Barva barva = NAZVY.get( nazev );
if( barva == null ) {
barva = NAZVY_BHC.get(nazev);
}
return barva;
}
/***************************************************************************
* Obsahuje-li nazev diakritiku, ulozi do prislusne mapy
* jeho verzi bez diakritiky.
*/
private void pridejNazevBezDiakritiky() {
String bhc = IO.odhackuj( nazev );
if( ! nazev.equals(bhc) ) {
NAZVY_BHC.put(bhc, this);
}
}
// /***************************************************************************
// * Vytvori ze zadanych slozek cele cislo a zabali je do typu Integer.
// *
// * @param s retezec urceny ke konverzi
// * @return Integer z barevnych slozek
// */
// private static Integer slozky( int r, int g, int b, int a )
// {
// int i = ((a & 0xFF) << 24) |
// ((r & 0xFF) << 16) |
// ((g & 0xFF) << 8) |
// ((b & 0xFF) << 0);
// return Integer.valueOf( i );
// }
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
//
// /***************************************************************************
// * Testovaci metoda
// */
// public static void test()
// {
// vypisZnameNazvy();
// System.out.println( "Nazvy: " + Arrays.asList(getZnameNazvy()) );
// System.out.println( "Barvy: " + Arrays.asList(getZnameBarvy()) );
// for( Barva b : getZnameBarvy() )
// {
// System.out.println();
// System.out.println( b.getCharakteristikaDec() );
// System.out.println( b.getCharakteristikaHex() );
// }
// Barva divna = new Barva( 1, 2, 3, 255, "divna" );
// System.out.println("\nDivna: " + divna.getCharakteristikaDec() );
// Barva prusvitna = getBarva( 255, 0, 0, 128, "prusvitna" );
// System.out.println("\nPrusvitna: "+prusvitna.getCharakteristikaDec());
// try
// {
// System.out.println();
// getBarva( 1, 2, 3, 5, "divna" );
// }catch( IllegalArgumentException iae ) {
// System.out.println("Vyjimka: " + iae );
// System.out.println("Vyjimka na existujici nazev vyhozena spravne");
// }
// try
// {
// System.out.println();
// getBarva( 1, 2, 3, 255, "podivna" );
// }catch( IllegalArgumentException iae ) {
// System.out.println("Vyjimka: " + iae );
// System.out.println("Vyjimka na existujici color vyhozena spravne");
// }
// vypisZnameNazvy();
// }
// /** @param ppr Paremtry prikazoveho radku - nepouzite */
// public static void main( String[]ppr ) {test();} /**/
}
Raw
Displej_projekt_src_knihovna_Cara.java
package knihovna;
/*******************************************************************************
* Trida pro praci s carou komunikujici s aktivnim platnem.
* Cara je urcena svymi krajnimi body, pricemz souradnice pocatecniho bodu
* je soucasne povazovana za pozici cele instance.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Cara extends APosuvny
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Pocatecni barva nakreslene instance v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada -
* pro caru Barva.CERNA. */
public static final Barva IMPLICITNI_BARVA = Barva.CERNA;
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private int kx; //xBodova -ova souradnice konce
private int ky; //Bodova y-ova souradnice konce
private Barva barva; //Barva instance
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* Koncit bude ve stredu platna.
*/
public Cara()
{
this( 0, 0, SP.getKrok()*SP.getSloupcu()/2,
SP.getKrok()*SP.getRadku()/2 );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param kx x-ova souradnice koncoveho bodu instance
* @param ky y-ova souradnice koncoveho bodu instance
*/
public Cara(int x, int y, int kx, int ky)
{
this( x, y, kx, ky, IMPLICITNI_BARVA );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param pocatek Pozice pocatku instance
* @param konec Pozice koncoveho bodu instance
*/
public Cara(Pozice pocatek, Pozice konec)
{
this( pocatek.x, pocatek.y, konec.x, konec.y, IMPLICITNI_BARVA );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param pocatek Pozice pocatku instance
* @param konec Pozice koncoveho bodu instance
* @param barva Barva vytvarene instance
*/
public Cara(Pozice pocatek, Pozice konec, Barva barva)
{
this( pocatek.x, pocatek.y, konec.x, konec.y, barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param kx x-ova souradnice koncoveho bodu instance
* @param ky y-ova souradnice koncoveho bodu instance
* @param barva Barva vytvarene instance
*/
public Cara(int x, int y, int kx, int ky, Barva barva)
{
super( x, y );
this.kx = kx;
this.ky = ky;
this.barva = barva;
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Nastavi novou pozici instance.
* Koncovy bod se pritom presune tak,
* aby zustala zachovana velikost a smer instance.
*
* @param x Nova x-ova pozice instance
* @param y Nova y-ova pozice instance
*/
@Override
public void setPozice( int x, int y )
{
kx += x - super.getX();
ky += y - super.getY();
super.setPozice( x, y );
SP.prekresli();
}
/***************************************************************************
* Vrati x-ovou souradnici koncoveho bodu instance.
*
* @return x-ova souradnice koncoveho bodu.
*/
public int getKX()
{
return kx;
}
/***************************************************************************
* Vrati y-ovou souradnici koncoveho bodu instance.
*
* @return y-ova souradnice koncoveho bodu.
*/
public int getKY()
{
return ky;
}
/***************************************************************************
* Vrati pozici koncoveho bodu instance.
*
* @return Pozice koncoveho bodu.
*/
public Pozice getKPozice()
{
return new Pozice( getKX(), getKY() );
}
/***************************************************************************
* Nastavi novou pozici koncoveho bodu instance.
*
* @param kx Nova x-ova souradnice koncoveho bodu
* @param ky Nova y-ova souradnice koncoveho bodu
*/
public void setKPozice( int kx, int ky )
{
this.kx = kx;
this.ky = ky;
SP.prekresli();
}
/***************************************************************************
* Nastavi pozici koncoveho bodu instance.
*
* @param kpozice Nova pozice koncoveho bodu.
*/
public void setKPozice( Pozice kpozice )
{
setPozice( kpozice.x, kpozice.y );
}
/***************************************************************************
* Vrati barvu instance.
*
* @return Instance tridy Barva definujici nastavenou barvu.
*/
public Barva getBarva()
{
return barva;
}
/***************************************************************************
* Nastavi novou barvu instance.
*
* @param nova Pozadovana nova barva.
*/
public void setBarva(Barva nova)
{
barva = nova;
SP.prekresli();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli( Kreslitko kreslitko )
{
kreslitko.kresliCaru( getX(), getY(), kx, ky, getBarva() );
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Vrati textovou reprezentaci dane instanci.
* Pouziva se predevsim pri ladeni.
*
* @return Nazev tridy nasledovany poradim a souradnicemi krajnich bodu
*/
@Override
public String toString()
{
return super.toString() + ", kx=" + kx + ", ky=" + ky +
", barva=" + barva;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
/***************************************************************************
* Spoji carou zadane body.
*
* @param px x-ova souradnice pocatku, x=0 ma levy okraj platna
* @param py y-ova souradnice pocatku, y=0 ma horni okraj platna
* @param kx x-ova souradnice koncoveho bodu
* @param ky y-ova souradnice koncoveho bodu
*/
public void spoj( int px, int py, int kx, int ky )
{
setPozice( px, py );
this.kx = kx;
this.ky = ky;
SP.prekresli();
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Ctverec.java
package knihovna;
/*******************************************************************************
* Trida pro praci s ctvercem na virtualnim platne.
* Ctverec je definovan jako potomek obdelniku,
* pricemz pri nastavovani rozmeru nastavi mensi ze zadanych velikosti.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Ctverec extends Obdelnik
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* vysku a sirku 1 pole.
*/
public Ctverec()
{
super( 0, 0, SP.getKrok(), SP.getKrok() );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param strana Delka strany vytvarene instance, strana > 0
*/
public Ctverec( int x, int y, int strana )
{
super( x, y, strana, strana );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param pocatek Pozice pocatku instance
* @param strana Delka strany vytvarene instance, strana > 0
*/
public Ctverec( Pozice pocatek, int strana )
{
super( pocatek.x, pocatek.y, strana, strana );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery a barvou.
*
* @param pocatek Pozice pocatku instance
* @param strana Delka strany vytvarene instance, strana > 0
* @param barva Barva instance
*/
public Ctverec(Pozice pocatek, int strana, Barva barva)
{
this( pocatek.x, pocatek.y, strana, barva );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici implicitni barvu.
*
* @param oblast Oblast definujici pozici a rozmer instance
*/
public Ctverec(Oblast oblast)
{
this( oblast.x, oblast.y, Math.min(oblast.sirka, oblast.vyska) );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici zadanou barvu.
*
* @param oblast Oblast definujici pozici a rozmer instance
* @param barva Barva instance
*/
public Ctverec(Oblast oblast, Barva barva)
{
this( oblast.x, oblast.y, Math.min(oblast.sirka, oblast.vyska), barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param strana Delka strany vytvarene instance, strana > 0
* @param barva Barva vytvareneho ctverce
*/
public Ctverec( int x, int y, int strana, Barva barva )
{
super( x, y, strana, strana, barva );
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Nastavi delku strany ctverce jako mensi ze zadanych delek.
* Prekryva prislusnou metodu rodickovske tridy tak,
* aby upraveny obrazec "nevycnival" ze zadane oblasti.
*
* @param sirka kandidat na delku strany ctverce - sirka opsaneho obdelnika
* @param vyska kandidat na delku strany ctverce - vyska opsaneho obdelnika
*/
@Override
public void setRozmer(int sirka, int vyska)
{
int strana = Math.min( sirka, vyska );
super.setRozmer( strana, strana );
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== OSTATNI PREKRYTE METODY RODICOVSKE TRIDY ==================================
//== OSTATNI METODY INSTANCI ===================================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Elipsa.java
package knihovna;
/*******************************************************************************
* Trida pro praci s elipsou komunikujici s aktivnim platnem.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Elipsa extends AHybaci
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Pocatecni barva nakreslene instance v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada -
* pro elipsu Barva.MODRA. */
public static final Barva IMPLICITNI_BARVA = Barva.MODRA;
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private Barva barva; //Barva instance
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* vysku rovnu kroku a sirku dvojnasobku kroku (tj. implicitne 50x100 bodu).
*/
public Elipsa()
{
this( 0, 0, 2*SP.getKrok(), SP.getKrok() );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka >= 0
* @param vyska Vyska vytvarene instance, vyska >= 0
*/
public Elipsa( int x, int y, int sirka, int vyska )
{
this( x, y, sirka, vyska, IMPLICITNI_BARVA );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery
* a barvou.
*
* @param pozice Pozice vytvarene instance
* @param rozmer Rozmer vytvarene instance
* @param barva Barva vytvarene instance
*/
public Elipsa(Pozice pozice, Rozmer rozmer, Barva barva)
{
this( pozice.x, pozice.y, rozmer.sirka, rozmer.vyska, barva );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici zadanou barvu.
*
* @param oblast Oblast definujici pozici a rozmer vytvarene instance
* @param barva Barva vytvarene instance
*/
public Elipsa(Oblast oblast, Barva barva)
{
this( oblast.x, oblast.y, oblast.sirka, oblast.vyska, barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka >= 0
* @param vyska Vyska vytvarene instance, vyska >= 0
* @param barva Barva vytvarene instance
*/
public Elipsa( int x, int y, int sirka, int vyska, Barva barva )
{
super( x, y, sirka, vyska );
this.barva = barva;
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Vrati barvu instance.
*
* @return Instance tridy Barva definujici nastavenou barvu.
*/
public Barva getBarva()
{
return barva;
}
/***************************************************************************
* Nastavi novou barvu instance.
*
* @param nova Pozadovana nova barva.
*/
public void setBarva(Barva nova)
{
barva = nova;
SP.prekresli();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli( Kreslitko kreslitko )
{
//Volam rodicovske verze pristupovych metod, abych mel jistotu,
//co se zavola, a aby se pri prekryti nektere z pouzitych metod
//nezavolalo neco jineho, co muze vratit pro mne nevhodnou hodnotu.
kreslitko.vyplnOval( super.getX(), super.getY(),
super.getSirka(), super.getVyska(),
barva );
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Prevede instanci na retezec. Pouziva se predevsim pri ladeni.
*
* @return Retezcova reprezentace dane instance.
*/
@Override
public String toString()
{
return super.toString() + ", barva=" + barva;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_IHybaci.java
package knihovna;
/*******************************************************************************
* Rozhrani {@code IHybaci} nedefinuje zadne nove metody,
* pouze slucuje pozadavky svych rodicu pod jednu strechu.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface IHybaci extends INafukovaci, IPosuvny
{
//== VEREJNE KONSTANTY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== OSTATNI METODY K IMPLEMENTACI =============================================
//== VNORENE TRIDY =============================================================
/***************************************************************************
* Trida definuje implicitni verze vsech metod pozadovanych
* implementovanym rozhranim.
*/
public static class Adapter implements IHybaci
{
/** {@inheritDoc} */
public Pozice getPozice() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setPozice( Pozice pozice ) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setPozice(int x, int y) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public Rozmer getRozmer() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setRozmer( Rozmer rozmer ) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setRozmer(int sirka, int vyska) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void nakresli( Kreslitko kreslitko ) {
throw new UnsupportedOperationException();
}
}
}
Raw
Displej_projekt_src_knihovna_IKresleny.java
package knihovna;
/*******************************************************************************
* Rozhrani IKresleny musi implementovat vsechny tridy, ktere chteji,
* aby jejich instance byly zobrazeny na animacnim platne.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface IKresleny
{
//== VEREJNE KONSTANTY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== OSTATNI METODY K IMPLEMENTACI =============================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli(Kreslitko kreslitko);
//== VNORENE TRIDY =============================================================
}
Raw
Displej_projekt_src_knihovna_IMultiposuvny.java
package knihovna;
/*******************************************************************************
* Rozhrani doplnuje metody sveho rodice o o metodu,
* kterou Multipresouvac zavola pote, do "dostrkal" svereny objekt
* do zadane cilove pozice.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface IMultiposuvny extends IPosuvny
{
//== VEREJNE KONSTANTY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== OSTATNI METODY K IMPLEMENTACI =============================================
/***************************************************************************
* Metoda vyvolana multipresouvacem pote, co dovedl svereny objekt
* do zadane cilove pozice. Pri svem typickem pouziti metoda nastavi
* novou cilovou pozici sve instance a instanci opet preda multipresouvaci.
*/
public void presunuto();
//== VNORENE TRIDY =============================================================
}
Raw
Displej_projekt_src_knihovna_INafukovaci.java
package knihovna;
/*******************************************************************************
* Rozhrani INafukovaci definuje povinou sadu metod, jez musi byt poskytovany
* objekty, ktere ma byt instance tridy Kompresor schopna "nafouknout".
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface INafukovaci extends IKresleny
{
//== VEREJNE KONSTANTY =========================================================
//== DEKLAROVANE METODY ========================================================
/***************************************************************************
* Vrati aktualni rozmer nafukovaciho objektu (vetsinou rozmer opsaneho
* obdelniku) jako instanci tridy {@code Rozmer}.
*
* @return Rozmer objektu.
*/
public Rozmer getRozmer();
/***************************************************************************
* Nastavi nove rozmery nafukovaciho objektu zadane jako jako instance
* tridy {@code Rozmer}; pozice objektu by se pritom nemela zmenit.
*
* @param rozmer Nove rozmery objektu
*/
public void setRozmer(Rozmer rozmer);
/***************************************************************************
* Nastavi novou velikost nafukovaciho objektu;
* pozice objektu by se pritom nemela zmenit.
*
* @param vyska Nova sirka objektu
* @param sirka Nova vyska objektu
*/
public void setRozmer(int sirka, int vyska);
//== ZDEDENE METODY ============================================================
//== VNORENE TRIDY =============================================================
/***************************************************************************
* Trida definuje implicitni verze vsech metod pozadovanych
* implementovanym rozhranim.
*/
public static class Adapter implements INafukovaci
{
/** {@inheritDoc} */
public Rozmer getRozmer() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setRozmer( Rozmer rozmer ) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setRozmer(int sirka, int vyska) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void nakresli( Kreslitko kreslitko ) {
throw new UnsupportedOperationException();
}
}
}
Raw
Displej_projekt_src_knihovna_IO.java
package knihovna;
import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/*******************************************************************************
* Knihovni trida {@code IO} obsahuje sadu metod
* pro jednoduchy vstup a vystup prostrednictvim dialogovyach oken
* spolu s metodou zastavujici beh programu na dany pocet milisekund
* a metodu prevadejici texty na ASCII jednoduchym odstranenim diakritiky.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public final class IO
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Prepravka pro nulove veikosti okraju. */
private static final Insets NULOVY_OKRAJ = new Insets(0, 0, 0, 0);
/** Rozdil mezi tloustkou ramecku okna ohlasovanou pred a po
* volani metody {@link #setResizable(boolean)}.
* Tento rozdil ve Windows ovlivnuje nastaveni velikosti a pozice.
* Pri {@code setResizable(true)} jsou jeho hodnoty vetsi,
* a proto se spocte se jako "true" - "false". */
private static final Insets INSETS_DIF;
/** Informace o tom, budou-li se opravovat pozice a rozmery oken. */
private static final boolean OPRAVOVAT;
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Pozice dialogovych oken. */
private static Point poziceOken = new Point(0,0);
/** Priznak testovaciho rezimu - je-li nastaven na {@code true},
* metoda {@link #zprava(Object)} neotevira dialogove okno
* a metoda {@link #cekej(int)} neceka. */
private static boolean testujeme = false;
//== STATICKY INICIALIZACNI BLOK - STATICKY KONSTRUKTOR ========================
/** Windows Vista + Windows 7 se neumeji dohodnout s Javou na skutecne
* velikosti oken a jejich ramu a v dusledku toho nefunguje spravne
* ani umistovani oken na zadane souradnice.
* Nasledujici staticky konstruktor se snazi zjistit chovani aktualniho
* operacniho systemu a podle toho pripravit potrebne korekce.
* Doufejme, ze zahy prestane byt potreba.
*/
static {
String os = System.getProperty("os.name");
if (os.startsWith("Windows")) {
JFrame okno = new JFrame();
okno.setLocation(-1000, -1000);
okno.setResizable(true);
okno.pack();
Insets insTrue = okno.getInsets();
// System.out.println("Insets - resizable=true: " + insTrue);
okno.setResizable(false);
Insets insFalse = okno.getInsets();
// System.out.println("Insets - resizable=false: " + insFalse);
Insets insets;
insets = new Insets(insTrue.top - insFalse.top,
insTrue.left - insFalse.left,
insTrue.bottom - insFalse.bottom,
insTrue.right - insFalse.right );
if (NULOVY_OKRAJ.equals(insets)) {
//Neverim mu, urcite keca
//TODO Proverit jak je to s tim prepoctem pozice a rozmeru
// int ubytek = (insTrue.left == 8) ? 5 : 1;
int ubytek = 1;
insets = new Insets(ubytek, ubytek, ubytek, ubytek);
}
INSETS_DIF = insets;
OPRAVOVAT = true;
// OPRAVOVAT = ! NULOVY_OKRAJ.equals(INSETS_DIF);
}
else {
INSETS_DIF = NULOVY_OKRAJ;
OPRAVOVAT = false;
}
// System.out.println("INSETS_DIF: " + INSETS_DIF +
// "\nOPRAVOVAT: " + OPRAVOVAT + "\n");
}
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
/***************************************************************************
* Pocka zadany pocet milisekund.
* Na preruseni nijak zvlast nereaguje - pouze skonci driv.
* Pred tim vsak nastavi priznak, aby volajici metoda poznala,
* ze vlakno bylo zadano o preruseni.
*
* @param milisekund Pocet milisekund, po nez se ma cekat.
*/
public static void cekej(int milisekund)
{
if (testujeme) {
Zpravodaj.zpravodaj.cekej(milisekund);
}
else {
try {
Thread.sleep(milisekund);
}catch( InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
/***************************************************************************
* Pri splneni zadane podminky otevre dialogove okno s napisem KONEC
* a po jeho zavreni ukonci program.
*
* @param plati Podminka, po jejimz splneni se program ukonci
*/
public static void konecKdyz(boolean plati)
{
konecKdyz(plati, null);
}
/***************************************************************************
* Pri splneni zadane podminky otevre dialogove okno se zadanou zpravou
* a po jeho zavreni ukonci program.
*
* @param plati Podminka, po jejimz splneni se program ukonci
* @param zprava Zprava vypisovana v dialogovem okne. Je-li {@code null}
* nebo prazdny retezec, vypise <b>{@code KONEC}</b>.
*/
public static void konecKdyz(boolean plati, String zprava)
{
if (plati) {
if ((zprava == null) || (zprava.equals(""))) {
zprava = "KONEC";
}
zprava(zprava);
System.exit(0);
}
}
/***************************************************************************
* Zbavi zadany text diakritickych znamenek; soucasne ale odstrani take
* vsechny dalsi znaky nespadajici do tabulky ASCII.
*
* @param text Text urceny k "odhackovani"
* @return "Odhackovany" text
*/
public static String odhackuj( String text )
{
return Odhackuj.text(text);
}
/***************************************************************************
* Nastavi pozici pristiho dialogoveho okna.
*
* @param x Vodorovna souradnice
* @param y Svisla souradnice
*/
public static void oknaNa( int x, int y )
{
poziceOken = new Point( x, y );
if (OPRAVOVAT) {
poziceOken.x += INSETS_DIF.left;
poziceOken.y += INSETS_DIF.top + INSETS_DIF.bottom;
}
}
/***************************************************************************
* Zobrazi dialogove okno se zpravou a umozni uzivateli odpovedet
* ANO nebo NE. Vrati informaci o tom, jak uzivatel odpovedel.
* Neodpovi-li a zavre dialog, ukonci program.
*
* @param dotaz Zobrazovany text otazky.
* @return <b>{@code true}</b> Odpovedel-li uzivatel <b>ANO</b>,
* <b>{@code false}</b> odpovedel-li <b>NE</b>
*/
public static boolean souhlas( Object dotaz )
{
JOptionPane jop = new JOptionPane(
dotaz,
JOptionPane.QUESTION_MESSAGE, //Message type
JOptionPane.YES_NO_OPTION //Option type
);
processJOP( jop );
int answer = (Integer)jop.getValue();
return (answer == JOptionPane.YES_OPTION);
}
/***************************************************************************
* Zobrazi dialogove okno s vyzvou k zadani realne hodoty;
* pri zavreni okna zaviracim tlacitkem ukonci aplikaci.
*
* @param vyzva Text, ktery se uzivateli zobrazi.
* @param doubleImpl Implicitni hodnota.
* @return Uzivatelem zadana hodnota, resp. potvrzena implicitni hodnota.
*/
public static double zadej( Object vyzva, double doubleImpl )
{
return Double.parseDouble( zadej( vyzva, ""+doubleImpl ).trim() );
}
/***************************************************************************
* Zobrazi dialogove okno s vyzvou k zadani celociselne hodoty;
* pri zavreni okna nebo stisku tlacitka Cancel
* se cela aplikace ukonci.
*
* @param vyzva Text, ktery se uzivateli zobrazi.
* @param intImpl Implicitni hodnota.
* @return Uzivatelem zadana hodnota, resp. potvrzena implicitni hodnota.
*/
public static int zadej( Object vyzva, int intImpl )
{
return Integer.parseInt( zadej( vyzva, ""+intImpl ).trim() );
}
/***************************************************************************
* Zobrazi dialogove okno s vyzvou k zadani textove hodoty;
* pri zavreni okna nebo stisku tlacitka Cancel
* se cela aplikace ukonci.
*
* @param vyzva Text, ktery se uzivateli zobrazi.
* @param stringImpl Implicitni hodnota.
* @return Uzivatelem zadana hodnota, resp. potvrzena implicitni hodnota.
*/
public static String zadej( Object vyzva, String stringImpl )
{
JOptionPane jop = new JOptionPane(
vyzva,
JOptionPane.QUESTION_MESSAGE, //Message type
JOptionPane.DEFAULT_OPTION //Option type - OK
);
jop.setWantsInput(true);
jop.setInitialSelectionValue(stringImpl);
processJOP(jop);
String answer = jop.getInputValue().toString();
return answer;
}
/***************************************************************************
* Zobrazi dialogove okno se zpravou a pocka,
* az uzivatel stiskne tlacitko OK;
* pri zavreni okna zaviracim tlacitkem ukonci celou aplikaci.
*
* @param text Zobrazovany text.
*/
public static void zprava( Object text )
{
if (testujeme) {
Zpravodaj.zpravodaj.zprava(text);
}
else {
JOptionPane jop = new JOptionPane(
text, //Sended message
JOptionPane.INFORMATION_MESSAGE //Message type
);
processJOP( jop );
}
}
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Trida IO je knihovni tridou a proto neni urcena k tomu,
* aby mela nejake instance.
*/
private IO() {}
//== ABSTRAKTNI METODY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
/***************************************************************************
* Creates a dialog from the given {@link JOptionPane}, makes it non-modal
* and waits for its closing leaving the entered value in the parameter's
* attribute {@code value}. If the user closed the dialog
* from the window's system menu, exit the whole application.
*
* @param jop
*/
private static void processJOP( JOptionPane jop )
{
final int WAITING=0, CANCELLED=1;
final Boolean[] USER = {true, false};
final JDialog jd = jop.createDialog((JDialog)null, "Information" );
jd.addWindowListener( new WindowAdapter()
{
/** Set the information about closing the window from its
* systme menu - the application will be cancelled. */
@Override
public void windowClosing(WindowEvent e) {
synchronized( USER ) {
USER[CANCELLED] = true;
System.exit( 1 );
}
}
@Override
public void windowDeactivated(WindowEvent e) {
poziceOken = jd.getLocation();
if( jd.isShowing() ) {
return;
}else{
jd.dispose();
synchronized( USER ) {
USER[WAITING] = false;
USER.notifyAll();
}
}
}
});
jd.setModal( false );
jd.setVisible( true );
jd.setLocation( poziceOken );
jd.toFront();
jd.setAlwaysOnTop(true);
// jd.setAlwaysOnTop(false);
//Waiting until the user answers or closes the dialog
synchronized( USER ) {
while( USER[WAITING] ) {
try {
USER.wait();
} catch (InterruptedException ie ) {
Thread.currentThread().interrupt();
}
}
}
}
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== INTERNI DATOVE TYPY =======================================================
/***************************************************************************
* Trida {@code Odhackuj_RUP} je knihovni tridou poskytujici metodu na
* odstraneni diakritiky ze zadaneho textu a nasledne prevedeni vsech znaku,
* jejichz kod je stale vetsi nez 127, na prislusne kodove
* unikove posloupnosti (escape sekvence).
*/
private static class Odhackuj
{
//== KONSTANTNI ATRIBUTY TRIDY =============================================
/** Mapa s prevody znaku do ASCII. */
private static final Map<Character,String> PREVOD =
new HashMap<Character, String>(64);
//== PROMENNE ATRIBUTY TRIDY ===============================================
//== STATICKY INICIALIZACNI BLOK - STATICKY KONSTRUKTOR ====================
static {
String[][] dvojice = {
{"A", "A"}, {"a", "a"}, {"AE", "AE"}, {"ae", "ae"},
{"C", "C"}, {"c", "c"},
{"D", "D"}, {"d", "d"}, {"\u00cb", "E"}, {"\u00eb", "e"},
{"E", "E"}, {"e", "e"},
{"E", "E"}, {"e", "e"},
{"I", "I"}, {"i", "i"}, {"\u00cf", "IE"}, {"\u00ef", "ie"},
{"L", "L"}, {"l", "l"}, {"L", "L"}, {"l", "l"},
{"N", "N"}, {"n", "n"},
{"O", "O"}, {"o", "o"}, {"OE", "OE"}, {"oe", "oe"},
{"O", "O"}, {"o", "o"},
{"R", "R"}, {"r", "r"}, {"R", "R"}, {"r", "r"},
{"S", "S"}, {"s", "s"},
{"T", "T"}, {"t", "t"},
{"U", "U"}, {"u", "u"}, {"UE", "UE"}, {"ue", "ue"},
{"U", "U"}, {"u", "u"},
{"Y", "Y"}, {"y", "y"}, {"\u0178", "YE"}, {"\u00ff", "ye"},
{"Z", "Z"}, {"z", "z"},
{"ss", "ss"},
{"<<", "<<"}, {">>", ">>"},
// {"",""},
};
for( String[] ss : dvojice ) {
PREVOD.put( new Character(ss[0].charAt(0)), ss[1] );
}
dvojice = null;
}
//== KONSTANTNI ATRIBUTY INSTANCI ==========================================
//== PROMENNE ATRIBUTY INSTANCI ============================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ====================================
//== OSTATNI NESOUKROME METODY TRIDY =======================================
/***********************************************************************
* Zbavi zadany text diakritickych znamenek - <b>POZOR</b> -
* Spolu s nimi odstrani take vsechny znaky s kodem vetsim nez 127.
*
* @param text Text urceny k "odhackovani"
* @return "Odhackovany" text
*/
public static String text( CharSequence text )
{
final int DELKA = text.length();
final StringBuilder sb = new StringBuilder(DELKA);
for( int i = 0; i < DELKA; i++ ) {
char c = text.charAt(i);
if( c < 128 ) {
sb.append(c);
}else if( PREVOD.containsKey(c) ) {
sb.append( PREVOD.get(c) );
}else {
sb.append( rozepis(c) );
}
}
return sb.toString();
}
//##########################################################################
//== KONSTRUKTORY A TOVARNI METODY =========================================
/** Soukromy konstruktor branici vytvoreni instance. */
private Odhackuj() {}
//== ABSTRAKTNI METODY =====================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =================================
//== OSTATNI NESOUKROME METODY INSTANCI ====================================
//== SOUKROME A POMOCNE METODY TRIDY =======================================
/***********************************************************************
* Rozepise zadany znak do prislusne \u0144ikove k\u00b4dove posloupnosti.
*
* @param c Prevadeny znak
* @return Text ve formatu \\uXXXX
*/
private static String rozepis(char c) {
return String.format( "\\u%04x", (int)c );
}
//== SOUKROME A POMOCNE METODY INSTANCI ====================================
//== INTERNI DATOVE TYPY ===================================================
//== TESTY A METODA MAIN ===================================================
}
///#############################################################################
///#############################################################################
///#############################################################################
/***************************************************************************
* Trida {@code Oprava} je knihovni tridou poskytujici metody
* pro opravy nejruznejsich nesrovnalosti tykajicich se prace
* s grafickym vstupem a vystupem.
*/
public static class Oprava
{
//== KONSTANTNI ATRIBUTY TRIDY =============================================
//== PROMENNE ATRIBUTY TRIDY ===============================================
//== STATICKY INICIALIZACNI BLOK - STATICKY KONSTRUKTOR ====================
//== KONSTANTNI ATRIBUTY INSTANCI ==========================================
//== PROMENNE ATRIBUTY INSTANCI ============================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ====================================
//== OSTATNI NESOUKROME METODY TRIDY =======================================
/***********************************************************************
* Ve Windows 7 pouzivajicich definuje Java jinou velikost okna,
* nez odpovida velikosti panelu obrazku.
*
* @param cont Kontejner, jehoz rozmery upravujeme
*/
public static void poziceOkna(Container cont)
{
Point loc;
if (OPRAVOVAT) {
loc = cont.getLocation();
cont.setLocation(loc.x + INSETS_DIF.left,
loc.y + INSETS_DIF.top);
}
}
/***********************************************************************
* Ve Windows 7 definuje Java jinou velikost okna,
* nez odpovida velikosti panelu obrazku.
*
* @param cont Kontejner, jehoz rozmery upravujeme
*/
public static void rozmerOkna(Container cont)
{
Dimension dim;
if (OPRAVOVAT) {
dim = cont.getSize();
cont.setSize(dim.width - INSETS_DIF.left - INSETS_DIF.right,
dim.height- INSETS_DIF.top - INSETS_DIF.bottom);
}
}
//##########################################################################
//== KONSTRUKTORY A TOVARNI METODY =========================================
/** Soukromy konstruktor branici vytvoreni instance. */
private Oprava() {}
//== ABSTRAKTNI METODY =====================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =================================
//== OSTATNI NESOUKROME METODY INSTANCI ====================================
//== SOUKROME A POMOCNE METODY TRIDY =======================================
//== SOUKROME A POMOCNE METODY INSTANCI ====================================
//== INTERNI DATOVE TYPY ===================================================
//== TESTY A METODA MAIN ===================================================
}
///#############################################################################
///#############################################################################
///#############################################################################
/***************************************************************************
* Instance rozhrani {@code ITester} predstavuji testovaci objekty,
* ktere chteji byt zpravovany o zajimavych udalostech.
*/
public interface ITester
{
//== KONSTANTY =============================================================
//== DEKLAROVANE METODY ====================================================
/***********************************************************************
* Oznani zavolani metody {@link IO.cekej(int)}
* a preda v parametru zadanou dobu cekani.
*
* @param ms Zadana doba cekani v milisekundach
*/
public void cekej(int ms);
/***********************************************************************
* Oznani zavolani metody {@link IO.zprava(Object)}
* a preda v parametru vypisovany text.
*
* @param zprava Zobrazovany text
*/
public void zprava(Object zprava);
//== ZDEDENE METODY ========================================================
//== INTERNI DATOVE TYPY ===================================================
}
///#############################################################################
///#############################################################################
///#############################################################################
/***************************************************************************
* Instance tridy {@code Zpravodaj} obstarava komunikaci mezi
* testovanymi a testovacimi objekty.
*/
public static class Zpravodaj
{
//== KONSTANTNI ATRIBUTY TRIDY =============================================
/** Prostrednik, ktery prihlasenym testovacim programum preposila
* zpravy o zavolani definovanych metod. */
public static final Zpravodaj zpravodaj = new Zpravodaj();
//== PROMENNE ATRIBUTY TRIDY ===============================================
//== STATICKY INICIALIZACNI BLOK - STATICKY KONSTRUKTOR ====================
//== KONSTANTNI ATRIBUTY INSTANCI ==========================================
/** Seznam prihlasenych testovacich programu,
* kterym budou preposilany zpravy o volani zadanych metod. */
private final List<ITester> seznam = new ArrayList<ITester>();
//== PROMENNE ATRIBUTY INSTANCI ============================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ====================================
//== OSTATNI NESOUKROME METODY TRIDY =======================================
//##########################################################################
//== KONSTRUKTORY A TOVARNI METODY =========================================
/** Soukromy konstruktor branici vytvoreni instance. */
private Zpravodaj() {}
//== ABSTRAKTNI METODY =====================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =================================
//== OSTATNI NESOUKROME METODY INSTANCI ====================================
/***********************************************************************
* Prida zadany objekt mezi objekty,
* kterym oznamuje zavolani definovanych metod.
*
* @param tester Pridavany testovaci objekt
*/
public void prihlas(ITester tester)
{
if (seznam.contains(tester)) { return; }
seznam.add(tester);
testujeme = true;
}
/***********************************************************************
* Odebere zadany objekt ze seznamu objetku,
* kterym oznamuje zavolani definovanych metod.
*
* @param tester Odebirany testovaci objekt
*/
public void odhlas(ITester tester)
{
seznam.remove(tester);
if (seznam.isEmpty()) {
testujeme = false;
}
}
//== SOUKROME A POMOCNE METODY TRIDY =======================================
//== SOUKROME A POMOCNE METODY INSTANCI ====================================
/***********************************************************************
* Oznami zavolani metody {@link IO.cekej(int)}
* a preda v parametru zadanou dobu cekani.
*
* @param ms Zadana doba cekani v milisekundach
*/
private void cekej(int ms)
{
for (ITester it : seznam) {
it.cekej(ms);
}
}
/***********************************************************************
* Oznami zavolani metody {@link IO.zprava(Object)}
* a preda v parametru vypisovany text.
*
* @param zprava Zobrazovany text
*/
private void zprava(Object zprava)
{
for (ITester it : seznam) {
it.zprava(zprava);
}
}
//== INTERNI DATOVE TYPY ===================================================
//== TESTY A METODA MAIN ===================================================
}
///#############################################################################
///#############################################################################
///#############################################################################
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_IPosuvny.java
package knihovna;
/*******************************************************************************
* Rozhrani {@code IPosuvny} definuje povinou sadu metod, jez musi byt
* poskytovany objekty, ktere maji byt schopny posunu po animovanem platne.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface IPosuvny extends IKresleny
{
//== VEREJNE KONSTANTY =========================================================
//== DEKLAROVANE METODY ========================================================
/***************************************************************************
* Vrati aktualni pozici pposuvneho objektu (vetsinou pozici leveho horniho
* rohu opsaneho obdelniku) jako instanci tridy {@code Pozice}.
*
* @return Akutalni pozice objektu.
*/
public Pozice getPozice();
/***************************************************************************
* Presune posuvny objekt do nove pozice.
*
* @param pozice Nova pozice objektu.
*/
public void setPozice(Pozice pozice);
/***************************************************************************
* Nastavi novou pozici objektu.
*
* @param x Nova x-ova pozice objektu
* @param y Nova y-ova pozice objektu
*/
public void setPozice(int x, int y);
//== ZDEDENE METODY ============================================================
//== VNORENE TRIDY =============================================================
/***************************************************************************
* Trida definuje implicitni verze vsech metod pozadovanych
* implementovanym rozhranim.
*/
public static class Adapter implements IPosuvny
{
/** {@inheritDoc} */
public Pozice getPozice() {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setPozice( Pozice pozice ) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void setPozice(int x, int y) {
throw new UnsupportedOperationException();
}
/** {@inheritDoc} */
public void nakresli( Kreslitko kreslitko ) {
throw new UnsupportedOperationException();
}
}
}
Raw
Displej_projekt_src_knihovna_IPrizpusobivy.java
package knihovna;
/*******************************************************************************
* Rozhrani IPrizpusobivy je urceno pro instance, ktere chteji byt schopny
* reagovat na velikosti kroku a tim i policka aktivniho platna.
* Kdykoliv se zmeni velikost pole aktivniho platna, platno to oznami
* vsem prihlasenym prizpuosbivym posluchacum.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public interface IPrizpusobivy
{
//== VEREJNE KONSTANTY =========================================================
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
//== OSTATNI METODY INSTANCI ===================================================
/***************************************************************************
* Prihlasi-li se instance u aktivniho platna jako prizpusobivy posluchac,
* zavola aktivni platno tuto jeji metodu po kazde zmene kroku
* a tim i velikosti jeho pole.
*
* @param stary Puvodni velikost kroku.
* @param novy Nove nastavena velikost kroku.
*/
public void krokZmenen(int stary, int novy);
//== VNORENE TRIDY =============================================================
}
Raw
Displej_projekt_src_knihovna_Kompresor.java
package knihovna;
/*******************************************************************************
* Trida Kompresor slouzi ke zmene velikosti objektu
* implementujicich rozhrani INafukovaci.
* Oproti verzi z projektu _06_Rozhrani doplnuje moznost
* definovat u na/vy-fukovaneho objektu smer, v nemz se predpoklada kotvici bod,
* ktery se pri zmene rozmeru nehyba.
* Trida NENI vlaknove bezpecna (thread-safe). Nepredpoklada,
* ze jeji instance boudou volany simultanne z ruznych vlaken.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Kompresor
{
//== VEREJNE KONSTANTY =========================================================
//== SOUKROME KONSTANTY ========================================================
/** Doba mezi jednotlivymi "stouchy".*/
private static int CEKANI = 30;
/** Tento atribut je tu pouze pro zjednoduseni psani. */
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
//== ATRIBUTY TRIDY ============================================================
//== ATRIBUTY INSTANCI =========================================================
/** Specifikuje silu "nafukovani" objektu danou instanci kompresoru,
* tj. miru jeho prifouknuti. */
private int sila;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Konstruktor kompresoru se silou nafukovani 1 (sila nafukovani definuje
* pocet bodu, o nez se zvetsi rozmer objektu po jednom "stouchu").
*/
public Kompresor()
{
this( 1 );
}
/***************************************************************************
* Konstruktor kompresoru se zadanou silou nafukovani (sila nafukovani
* definuje pocet bodu, o nez se zvetsi rozmer objektu po jednom "stouchu").
*
* @param sila Sila nafukovani vytvareneho kompresoru
*/
public Kompresor(int sila)
{
this.sila = sila;
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
//== NOVE ZAVEDENE METODY INSTANCI =============================================
/***************************************************************************
* Metoda zvetsi zadanou instanci o zadany nasobek sily sveho kompresoru.
* Pri zmene velikosti se zachovava pomer stran.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Zvetsovany objekt
* @param stouchu Pocet prifouknuti o silu kompresoru
*/
public void prifoukni(INafukovaci koho, int stouchu )
{
Rozmer r = koho.getRozmer();
int x = r.sirka;
int y = r.vyska;
double d = delka( x, y );
foukej( koho, stouchu, sila*x/d, sila*y/d, Smer8.SEVEROZAPAD );
}
/***************************************************************************
* Metoda zvetsi zadanou instanci o petinasobek sily sveho kompresoru.
* Pri zmene velikosti se zachovava pomer stran.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Zvetsovany objekt
*/
public void prifoukni(INafukovaci koho )
{
prifoukni( koho, 5 );
}
/***************************************************************************
* Metoda zmensi zadanou instanci o zadany nasobek sily sveho kompresoru.
* Pri zmene velikosti se zachovava pomer stran.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Zmensovany objekt
* @param stouchu Pocet ufouknuti o silu kompresoru
*/
public void ufoukni(INafukovaci koho, int stouchu )
{
sila = -sila;
prifoukni( koho, stouchu );
sila = -sila;
}
/***************************************************************************
* Metoda zmensi zadanou instanci o petinasobek sily sveho kompresoru.
* Pri zmene velikosti se zachovava pomer stran.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Zmensovany objekt
*/
public void ufoukni(INafukovaci koho)
{
ufoukni( koho, 5 );
}
/***************************************************************************
* Nafoukne ci vyfoukne zadany objekt na pozadovanou velikost.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Na(vy)fukovany objekt
* @param sirka Pozadovana vysledna sirka objektu
* @param vyska Pozadovana vysledna vyska objektu
*/
public void nafoukniNa( INafukovaci koho, int sirka, int vyska )
{
nafoukniNa( koho, sirka, vyska, Smer8.SEVEROZAPAD, 0 );
}
/***************************************************************************
* Nafoukne ci vyfoukne zadany objekt na pozadovanou velikost.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Na(vy)fukovany objekt
* @param rozmer Pozadovany rozmer objektu
*/
public void nafoukniNa( INafukovaci koho, Rozmer rozmer )
{
nafoukniNa( koho, rozmer.sirka, rozmer.vyska );
}
/***************************************************************************
* Nafoukne ci vyfoukne zadany objekt na pozadovanou velikost.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Na(vy)fukovany objekt
* @param sirka Pozadovana vysledna sirka objektu
* @param vyska Pozadovana vysledna vyska objektu
* @param smer Smer od stredu obrazce, v nemz se nachazi pevny bod,
* ktery pri zmene rozmeru nemeni svoji pozici.
* smer==null oznacuje symetricky rust vuci stredu obrazce.
*/
public void nafoukniNa( IHybaci koho, int sirka, int vyska, Smer8 smer )
{
nafoukniNa( (INafukovaci)koho, sirka, vyska, smer, 0 );
}
/***************************************************************************
* Nafoukne ci vyfoukne zadany objekt na pozadovanou velikost.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Na(vy)fukovany objekt
* @param rozmer Pozadovany rozmer objektu
* @param smer Smer od stredu obrazce, v nemz se nachazi pevny bod,
* ktery pri zmene rozmeru nemeni svoji pozici.
* smer==null oznacuje symetricky rust vuci stredu obrazce.
*/
public void nafoukniNa( INafukovaci koho, Rozmer rozmer, Smer8 smer )
{
nafoukniNa( koho, rozmer.sirka, rozmer.vyska, smer, 0 );
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
/***************************************************************************
* Spocte delku prepony pravouhleho trojuelniku se zadanymi odvesnami.
*
* @param x Delka prvni odvesny
* @param y Delka druhe odvesny
*
* @return Delka prepony
*/
private static double delka( int x, int y )
{
return Math.sqrt(x*x + y*y);
}
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
/***************************************************************************
* Nafoukne ci vyfoukne zadany objekt na pozadovanou velikost.
* Nejprve ale zabezpeci, aby byl objekt zobrazen na platne.
*
* @param koho Na(vy)fukovany objekt
* @param sirka Pozadovana vysledna sirka objektu
* @param vyska Pozadovana vysledna vyska objektu
*/
private void nafoukniNa( INafukovaci koho, int sirka, int vyska,
Smer8 smer, int zaslepka )
{
Rozmer rozmer = koho.getRozmer();
int vodorovne = sirka - rozmer.sirka;
int svisle = vyska - rozmer.vyska;
int kroku = (int)(delka(vodorovne, svisle) / sila);
double dx = (double)vodorovne / kroku;
double dy = (double)svisle / kroku;
foukej( koho, kroku, dx, dy, smer );
}
/***************************************************************************
* Vykonna metoda, ktera zaridi vlastni nafouknuti, resp. vyfouknuti
* zadaneho objektu na zaklade pripravenych parametru.
*
* @param koho Objekt, jehoz velikost menime.
* @param stouchu Pocet kroku, v nichz velikost objektu zmenime.
* @param dx Zvetseni sirky objektu v jednom kroku.
* @param dy Zvetseni vysky objektu v jednom kroku.
*/
private void foukej( INafukovaci koho, int stouchu, double dx, double dy,
Smer8 smer )
{
IHybaci ih = null;
double dxx = 0, dyy = 0;
double x = 0, y = 0;
if( smer != Smer8.SEVEROZAPAD )
{
ih = (IHybaci)koho;
Pozice pozice = ih.getPozice();
x = pozice.getX() + .4;
y = pozice.getY() + .4;
if( (smer == Smer8.JIHOVYCHOD) ||
(smer == Smer8.VYCHOD) ||
(smer == Smer8.SEVEROVYCHOD) )
{
dxx = -dx;
}
else if( (smer == Smer8.SEVER) ||
(smer == Smer8.JIH) ||
(smer == Smer8.ZADNY) )
{
dxx = -dx/2;
}
if( (smer == Smer8.JIHOZAPAD) ||
(smer == Smer8.JIH) ||
(smer == Smer8.JIHOVYCHOD) )
{
dyy = -dy;
}
else if( (smer == Smer8.VYCHOD) ||
(smer == Smer8.ZAPAD) ||
(smer == Smer8.ZADNY) )
{
dyy = -dy/2;
}
}
SP.pridej( koho );
//Konstatnu pripocitavame proto, aby skoky byly vyrovnanejsi
Rozmer rozmer = koho.getRozmer();
double sirka = rozmer.sirka + .4;
double vyska = rozmer.vyska + .4;
while( stouchu-- > 0 )
{
IO.cekej(CEKANI);
sirka += dx;
vyska += dy;
SP.nekresli(); {
koho.setRozmer( (int)sirka, (int)vyska );
if( smer != Smer8.SEVEROZAPAD )
{
x += dxx;
y += dyy;
ih.setPozice( (int)x, (int)y );
}
} SP.vratKresli();
}
}
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Kreslitko.java
package knihovna;
import java.awt.*;
/*******************************************************************************
* Trida Kreslitko slouzi k zprostredkovani kreslicich cshopnosti objektum
* prihlasenym u {@code SpravcePlatna}.
* Je konstruovan jako adapter objektu {@code java.awt.Graphics2D}.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Kreslitko
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
private java.awt.Graphics2D g;
//== PROMENNE ATRIBUTY INSTANCI ================================================
private Barva barvaPozadi = null;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Inicializuje atribut adaptovanym objkektem.
* @param g
*/
public Kreslitko( Graphics2D g )
{
this.g = g;
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Nastavi font, kterym se budou sazet vypisovane texty.
*
* @param font Nastavovany font
*/
public void setFont( Font font )
{
g.setFont( font );
}
/***************************************************************************
* Nastavi barvu pozadi kreslenych objektu
*
* @param barva Nastavovana barva pozadi
*/
public void setPozadi( Barva barva )
{
g.setBackground( barva.getColor() );
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
//== NOVE ZAVEDENE METODY INSTANCI =============================================
/***************************************************************************
* Vykresli zadanou barvou na zadanych souradnicich nevyplneny oval
* zadaneho rozmeru.
*
* @param x x-ova souradnice instance, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y=0 ma horni okraj platna
* @param sirka Sirka kresleneho ovalu
* @param vyska Vyska kresleneho ovalu
* @param barva Barva kresleneho ovalu
*/
public void kresliOval( int x, int y, int sirka, int vyska, Barva barva )
{
g.setColor( barva.getColor() );
g.drawOval( x, y, sirka, vyska );
}
/***************************************************************************
* Vykresli zadanou barvou na zadanych souradnicich vyplneny oval
* zadaneho rozmeru.
*
* @param x x-ova souradnice instance, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y=0 ma horni okraj platna
* @param sirka Sirka kresleneho ovalu
* @param vyska Vyska kresleneho ovalu
* @param barva Barva kresleneho ovalu
*/
public void vyplnOval( int x, int y, int sirka, int vyska, Barva barva )
{
g.setColor( barva.getColor() );
g.fillOval( x, y, sirka, vyska );
}
/***************************************************************************
* Vykresli zadanou barvou na zadanych souradnicich nevyplneny obdelnik
* zadaneho rozmeru.
*
* @param x x-ova souradnice instance, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y=0 ma horni okraj platna
* @param sirka Sirka kresleneho obdelniku
* @param vyska Vyska kresleneho obdelniku
* @param barva Barva kresleneho obdelniku
*/
public void kresliRam( int x, int y, int sirka, int vyska, Barva barva )
{
g.setColor( barva.getColor() );
g.drawRect( x, y, sirka, vyska );
}
/***************************************************************************
* Vykresli zadanou barvou na zadanych souradnicich vyplneny obdelnik
* zadaneho rozmeru.
*
* @param x x-ova souradnice instance, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y=0 ma horni okraj platna
* @param sirka Sirka kresleneho obdelniku
* @param vyska Vyska kresleneho obdelniku
* @param barva Barva kresleneho obdelniku
*/
public void vyplnRam( int x, int y, int sirka, int vyska, Barva barva )
{
g.setColor( barva.getColor() );
g.fillRect( x, y, sirka, vyska );
}
/***************************************************************************
* Vykresli zadanou barvou nevyplneny mnohouhelnik se zadnymi vrcholy.
*
* @param x Pole x-ovych souradnic vrcholu
* @param y Pole y-ovych souradnic vrcholu
* @param barva Barva kresleneho obdelniku
*/
public void kresliPolygon( int[] x, int[] y, Barva barva )
{
g.setColor( barva.getColor() );
g.drawPolygon( x, y, Math.min(x.length, y.length) );
}
/***************************************************************************
* Vykresli zadanou barvou vyplneny mnohouhelnik se zadnymi vrcholy.
*
* @param x Pole x-ovych souradnic vrcholu
* @param y Pole y-ovych souradnic vrcholu
* @param barva Barva kresleneho obdelniku
*/
public void vyplnPolygon( int[] x, int[] y, Barva barva )
{
g.setColor( barva.getColor() );
g.fillPolygon( x, y, Math.min(x.length, y.length) );
}
/***************************************************************************
* Vykresli zadanou barvou caru se zadanymi vrcholy.
*
* @param x1 x-ova souradnice instance, x=0 ma levy okraj platna
* @param y1 y-ova souradnice instance, y=0 ma horni okraj platna
* @param x2 x-ova souradnice konce
* @param y2 y-ova souradnice konce
* @param barva Barva kresleneho obdelniku
*/
public void kresliCaru( int x1, int y1, int x2, int y2, Barva barva )
{
g.setColor( barva.getColor() );
g.drawLine( x1, y1, x2, y2 );
}
/***************************************************************************
* Vypise zadanou barvou zadany text na zadanych souradnicich.
*
* @param text Vypisovany text
* @param x x-ova souradnice instance, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y=0 ma horni okraj platna
* @param barva Barva kresleneho obdelniku
*/
public void kresliText( String text, int x, int y, Barva barva )
{
g.setColor( barva.getColor() );
g.drawString( text, x, y );
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Kruh.java
package knihovna;
/*******************************************************************************
* Trida pro praci s kruhem na virtualnim platne.
* Kruh je definovan jako potomek elipsy,
* pricemz pri nastavovani rozmeru nastavi mensi ze zadanych velikosti.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Kruh extends Elipsa
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* vysku a sirku 1 pole.
*/
public Kruh()
{
super( 0, 0, SP.getKrok(), SP.getKrok() );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param prumer Prumer vytvarene instance, prumer > 0
*/
public Kruh(int x, int y, int prumer)
{
super( x, y, prumer, prumer );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param pocatek Pozice pocatku instance
* @param prumer Prumer vytvarene instance, prumer > 0
*/
public Kruh( Pozice pocatek, int prumer )
{
super( pocatek.x, pocatek.y, prumer, prumer );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery a barvou.
*
* @param pocatek Pozice pocatku instance
* @param prumer Prumer instance
* @param barva Barva instance
*/
public Kruh(Pozice pocatek, int prumer, Barva barva)
{
this( pocatek.x, pocatek.y, prumer, barva );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici implicitni barvu.
*
* @param oblast Oblast definujici pozici a rozmer instance
*/
public Kruh(Oblast oblast)
{
this( oblast.x, oblast.y, Math.min(oblast.sirka, oblast.vyska) );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici zadanou barvu.
*
* @param oblast Oblast definujici pozici a rozmer instance
* @param barva Barva instance
*/
public Kruh(Oblast oblast, Barva barva)
{
this( oblast.x, oblast.y, Math.min(oblast.sirka, oblast.vyska), barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param prumer Prumer vytvarene instance, prumer > 0
* @param barva Barva vytvarene instance
*/
public Kruh(int x, int y, int prumer, Barva barva)
{
super( x, y, prumer, prumer, barva );
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Nastavi prumer kruhu jako mensi ze zadanych delek.
* Prekryva prislusnou metodu rodickovske tridy tak,
* aby upraveny obrazec "nevycnival" ze zadane oblasti.
*
* @param sirka kandidat na prumer kruhu - sirka opsane elipsy
* @param vyska kandidat na prumer kruhu - vyska opsane elipsy
*/
@Override
public void setRozmer(int sirka, int vyska)
{
int prumer = Math.min( sirka, vyska );
super.setRozmer( prumer, prumer );
}
/***************************************************************************
* Vrati prumer kruhu.
*
* @return Prumer kruhu.
*/
public int getPrumer()
{
return super.getSirka();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== OSTATNI PREKRYTE METODY RODICOVSKE TRIDY ==================================
//== OSTATNI METODY INSTANCI ===================================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Multipresouvac.java
package knihovna;
import java.util.*;
/*******************************************************************************
* Instance tridy Multipresouvac je jedinacek slouzici
* k presunu nekolika grafickych objektu zaroven.
* Obdobne jako SpravcePlatna prijima prostrednictvim metody <code>pridej</code>
* do spravy objekty, kterymi pak po platne pohybuje.
* <p>
* Tyto objekty musi byt typu IPosuvny. Je-li objekt dokonce typu IMultiposuvny,
* tak pote, co objekt presune do zadane cilove pozice, zavola jeho metodu
* <code>presunuto</code>, ktera muze provest libovolnou akci (vetsinou preda
* znovu objekt multipresouvaci, aby jej presunul do dalsi pozice).
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Multipresouvac
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Implicitni hodnota periody = pocet milisekund, ktere uplynou mezi
* dvema naslednymi prekreslenimi presouvanych objektu. */
private static final int PERIODA_0 = 50;
/** Tento atribut je tu pouze pro zjednoduseni psani. */
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
/** Jedina existujici instance multipresouvace. */
private static final Multipresouvac jedinacek = new Multipresouvac();
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Pocet milisekund, ktere uplynou mezi dvema naslednymi prekreslenimi
* presouvanych objektu. */
private final int perioda = PERIODA_0;
/** Seznam posouvanych objektu. Je deklarovany jako mapa,
* aby v nem bylo mozno rychle testovat pritomnost prvku.
* Linkovanou mapou je proto, protoze bude pri kresleni velice casto
* porchazen s vysokymi pozadavky na rychlost. */
private final Map<IPosuvny,Animace> presouvane =
new LinkedHashMap<IPosuvny,Animace>();
/** Tabulka dvojic [IPosuvny;Animace] reprezentovana jako mnozina. */
private final Set<Map.Entry<IPosuvny,Animace>> dvojice =
presouvane.entrySet();
/** Casovac, ktery se postara o opakovane vykreslovani sverenych objektu.*/
private final Timer timer = new Timer();
//== PROMENNE ATRIBUTY INSTANCI ================================================
/** Promenna ovladajici beh multipresouvace. */
private Multipresun multipresun = null;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
/***************************************************************************
* Vrati hodnotu periody = pocet milisekund, ktere uplynou mezi dvema
* naslednymi prekreslenimi presouvanych objektu.
*
* @return Perioda prekreslovani v milisekundach.
*/
public int getPerioda()
{
return perioda;
}
/***************************************************************************
* Vrati frekvenci prekreslovani, tj. pocet prekresleni za sekundu.
*
* @return Frekvence prekreslovani.
*/
public int getFrekvence()
{
return 1000 / perioda;
}
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vrati multipresouvac s periodou 50 ms.
* @return
*/
public static Multipresouvac getInstance()
{
return jedinacek;
}
/***************************************************************************
* Vytvori novy multipresouvac - vsechna potrebna nastaveni
* jsou soucasti deklaraci atributu.
*/
private Multipresouvac()
{
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Vrati pole se vsemi prave presouvanymi objekty. Vraceny seznam je vsak
* platny pouze v dobe volani. Vzapeti na to mohou byt nektere objekty
* dovezeny do svych cilovych pozic a mohou seznam "opustit".
*
* @return Pole prave presouvanych objektu.
*/
public IPosuvny[] getPresouvane()
{
synchronized( presouvane )
{
return presouvane.keySet().toArray(new IPosuvny[0]);
}
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== OSTATNI PREKRYTE METODY RODICOVSKE TRIDY ==================================
//== OSTATNI METODY INSTANCI ===================================================
/***************************************************************************
* Presune zadany posuvny objekt do pozadovane cilove pozice
* za zadanou dobu.
*
* @param ip Presouvany objekt
* @param xn Vodorovna souradnice cilove pozice
* @param yn Svisla souradnice cilove pozice
* @param sekund Doba, kterou bude presun trvat, v sekundach
*/
public void presun( IPosuvny ip, int xn, int yn, double sekund )
{
if( sekund <= 0 ) {
throw new IllegalArgumentException(
"Doba presunu musi byt kladna!");
}
presun( ip, xn, yn, 0, sekund*1000 );
}
/***************************************************************************
* Presune zadany posuvny objekt do pozadovane cilove pozice
* za zadanou dobu.
*
* @param ip Presouvany objekt
* @param pozice Pozadovana cilove pozice
* @param sekund Doba, kterou bude presun trvat, v sekundach
*/
public void presun( IPosuvny ip, Pozice pozice, double sekund )
{
presun( ip, pozice.x, pozice.y, sekund );
}
/***************************************************************************
* Presune zadany posuvny objekt do pozadovane cilove pozice
* za zadanou dobu.
*
* @param ip Presouvany objekt
* @param pozice Pozadovana cilove pozice
* @param rychlost Pocet bodu, o ktere se objekt presune za sekundu
*/
public void presun( IPosuvny ip, Pozice pozice, int rychlost )
{
presun( ip, pozice.x, pozice.y, rychlost, 0 );
}
/***************************************************************************
* Presune zadany posuvny objekt do pozadovane cilove pozice
* za zadanou dobu.
*
* @param ip Presouvany objekt
* @param xn Vodorovna souradnice cilove pozice
* @param yn Svisla souradnice cilove pozice
* @param rychlost Pocet bodu, o ktere se objekt presune za sekundu
*/
public void presun( IPosuvny ip, int xn, int yn, int rychlost )
{
if( rychlost <= 0 ) {
throw new IllegalArgumentException(
"Rychlost presunu musi byt kladna!");
}
presun( ip, xn, yn, rychlost, 0 );
}
/***************************************************************************
* Zastavi pozadovany objekt, tj. vyjme jej ze seznamu objektu,
* s nimiz pohybuje. Pro jeho pristi rozpohybovani je potreba
* znovu pozadat multipresouvac o jeho presunuti.
*
* @param ip Zastavovany objekt
*
* @return Informace o tom, byl-li objekt mezi presouvanymi
*/
public boolean zastav( IPosuvny ip )
{
synchronized( presouvane )
{
if( presouvane.containsKey(ip) )
{
presouvane.remove( ip );
return true;
}
return false;
}
}
/***************************************************************************
* Zastavi zastavi presouvace a zrusi vsechny plany presunu.
*/
public void zastavVse()
{
stop();
synchronized( presouvane )
{
presouvane.clear();
}
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
/***************************************************************************
* Presune zadany posuvny objekt do pozadovane cilove pozice
* za zadanou dobu nebo zadanou rychlosti.
*
* @param ip Presouvany objekt
* @param xn Vodorovna souradnice cilove pozice
* @param yn Svisla souradnice cilove pozice
* @param rychlost Pocet bodu, o ktere se objekt presune za sekundu
* @param milisekund Doba, kterou bude presun trvat, v sekundach
*/
private void presun( IPosuvny ip, int xn, int yn,
int rychlost, double milisekund )
{
if( ip == null ) {
throw new NullPointerException(
"Presouvany objekt nesmi byt null!");
}
Animace a = new Animace( ip, xn, yn, rychlost, milisekund );
synchronized(presouvane)
{
if( presouvane.get(ip) != null )
{
a = null;
throw new IllegalStateException(
"Pridavany objekt jiz je mezi presouvanymi!");
}
// SP.pridej( ip );
presouvane.put( ip, a );
start();
}//synchronized(presouvane)
}
/***************************************************************************
* Ukonci multipresun a tim uvolni procesor.
*/
private synchronized void stop()
{
if( multipresun == null ) {
return;
}
multipresun.cancel();
multipresun = null;
}
/***************************************************************************
* Spusti novy multipresun.
*/
private synchronized void start()
{
if( multipresun == null )
{
multipresun = new Multipresun();
timer.scheduleAtFixedRate( multipresun, perioda, perioda );
//timer.schedule(multipresun, perioda, perioda);
}
}
//== VNORENE A VNITRNI TRIDY ===================================================
//==========================================================================
/***************************************************************************
* Soukroma vnitrni trida, jejiz instance sdruzuji vsechny potrebne
* informace o presouvanem objektu. Funguje pouze jako prepravka.
*/
private class Animace
{
double x, y; //Aktualni souradnice objektu
double dx, dy; //Prirustek souradnic v jednom kroku
IPosuvny objekt; //Animovany objekt
int kroku; //Pocet kroku potrebnych pro presun.
/***********************************************************************
* Vytvori animaci na zaklade zadaneho objektu, jeho cilovych
* souradnic a doby, behem niz ma techto souradnic dosahnout.
* nebo rychlosti, s niz se ma k tomuto cili presouvat.
* Volajici metoda musi zabezpecit, aby doba nebo rychlost byla nulova.
*
* @param ip Presouvany objekt
* @param xn Vodorovna souradnice cile
* @param yn Svisla souradnice cile
* @param rychlost Pocet bodu "zdolanych" za sekundu
* @param doba Pocet milisekund
*/
Animace( IPosuvny ip, int xn, int yn, int rychlost, double doba )
{
objekt = ip;
Pozice p = ip.getPozice();
x = p.x;
y = p.y;
dx = (xn - x);
dy = (yn - y);
if( rychlost > 0 )
{
double vzdalenost = Math.hypot( dx, dy );
kroku = (int)(1000 * vzdalenost / (rychlost * perioda));
}
else
{
kroku = (int)(doba / perioda);
}
if( kroku < 1 ) {
kroku = 1;
}
//Posunuti zlepsuje rozlozeni presunu pri malem poctu kroku
x += 0.4;
y += 0.4;
dx /= kroku;
dy /= kroku;
}
}//private class Animace
//==========================================================================
/***************************************************************************
* Instance tridy jsou ulohy ralizujici vlastni multipresun.
* Multipresun je definvan jako samostatna trida proto, aby jej bylo mozno
* pri ukonceni vsech zadanych presunu vypnout a pri vzniku novych
* pozadavku na presun zase zapnout.
*/
private class Multipresun extends TimerTask
{
/***********************************************************************
* Metoda vyzadovana rozhranim Runable implementovanym rodicovskou
* tridou TimerTask - tuto metodu zavola Timer pokazde,
* kdyz se rozhodne spustit dalsi provedeni opakovaneho ukolu
* (Timertask) = multipresunu.
*/
public void run()
{
//Pri prekreslovani se nesmi menit pocet objektu v seznamu
synchronized( presouvane )
{
Iterator it = dvojice.iterator();
SP.nekresli(); {
while( it.hasNext() )
{
Animace a = (Animace)(((Map.Entry)it.next()).getValue());
a.x += a.dx;
a.y += a.dy;
a.objekt.setPozice((int)a.x, (int)a.y);
if( --a.kroku == 0 )
{
it.remove();
if( a.objekt instanceof IMultiposuvny )
{
final IMultiposuvny aa =
(IMultiposuvny) (a.objekt);
Thread t = new Thread(a.toString()) {
@Override
public void run() {
aa.presunuto();
}//public void run()
};//Thread t = new Thread()
t.start();
}
//Pri vyprazdneni seznamu zrus ulohu
if( presouvane.size() <= 0)
{
stop();
break;
}
}
}//while
} SP.vratKresli();
}//synchronized( presouvane )
}//public void run()
}//private class Multipresun extends TimerTask
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Obdelnik.java
package knihovna;
/*******************************************************************************
* Trida pro praci s obdelnikem komunikujicim s aktivnim platnem.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Obdelnik extends AHybaci
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Pocatecni barva nakreslene instance v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada -
* pro obdelnik Barva.CERVENA. */
public static final Barva IMPLICITNI_BARVA = Barva.CERVENA;
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private Barva barva; //Barva instance
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* vysku rovnu kroku a sirku dvojnasobku kroku (tj. implicitne 50x100 bodu).
*/
public Obdelnik()
{
this( 0, 0, 2*SP.getKrok(), SP.getKrok() );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka >= 0
* @param vyska Vyska vytvarene instance, vyska >= 0
*/
public Obdelnik(int x, int y, int sirka, int vyska)
{
this( x, y, sirka, vyska, IMPLICITNI_BARVA );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery
* a barvou.
*
* @param pozice Pozice vytvarene instance
* @param rozmer Rozmer vytvarene instance
* @param barva Barva vytvarene instance
*/
public Obdelnik(Pozice pozice, Rozmer rozmer, Barva barva)
{
this( pozice.x, pozice.y, rozmer.sirka, rozmer.vyska, barva );
}
/***************************************************************************
* Vytvori novou instanci vyplnujici zadanou oblast
* a majici zadanou barvu.
*
* @param oblast Oblast definujici pozici a rozmer vytvarene instance
* @param barva Barva vytvarene instance
*/
public Obdelnik(Oblast oblast, Barva barva)
{
this( oblast.x, oblast.y, oblast.sirka, oblast.vyska, barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka >= 0
* @param vyska Vyska vytvarene instance, vyska >= 0
* @param barva Barva vytvarene instance
*/
public Obdelnik( int x, int y, int sirka, int vyska, Barva barva )
{
super( x, y, sirka, vyska );
this.barva = barva;
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Vrati barvu instance.
*
* @return Instance tridy Barva definujici nastavenou barvu.
*/
public Barva getBarva()
{
return barva;
}
/***************************************************************************
* Nastavi novou barvu instance.
*
* @param nova Pozadovana nova barva.
*/
public void setBarva(Barva nova)
{
barva = nova;
SP.prekresli();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli( Kreslitko kreslitko )
{
//Volam rodicovske verze pristupovych metod, abych mel jistotu,
//co se zavola, a aby se pri prekryti nektere z pouzitych metod
//nezavolalo neco jineho, co muze vratit pro mne nevhodnou hodnotu.
kreslitko.vyplnRam( super.getX(), super.getY(),
super.getSirka(), super.getVyska(),
barva );
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Prevede instanci na retezec. Pouziva se predevsim pri ladeni.
*
* @return Retezcova reprezentace dane instance.
*/
@Override
public String toString()
{
return super.toString() + ", barva=" + barva;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Oblast.java
package knihovna;
/*******************************************************************************
* Trida {@code Oblast} slouzi jako prepravka uchovavajici informace
* o pozici a rozmeru dane obdelnikove oblasti.
* Proto jsou jeji atributy deklarovany jako verejne konstanty.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Oblast
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Vodorovna souradnice dane oblasti, tj. jejiho leveho horniho rohu. */
public final int x;
/** Svisla souradnice dane oblasti, tj. jejiho leveho horniho rohu. */
public final int y;
/** Sirka oblasti. */
public final int sirka;
/** Vyska oblasti. */
public final int vyska;
//== PROMENNE ATRIBUTY INSTANCI ================================================
private int hashCode = Integer.MIN_VALUE;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
/***************************************************************************
* Zjisti oblast zaujimanou zadanym objektem.
*
* @param ih Objekt, jehoz oblast zjistujeme
* @return Oblast zaujimana zadanym objektem
*/
public static Oblast get(IHybaci ih)
{
return new Oblast( ih.getPozice(), ih.getRozmer() );
}
/***************************************************************************
* Nastavi pro zadany hybaci objekt jeho oblast, tj. pozici a rozmer.
*
* @param ih Objekt, jehoz oblast nastavujeme
* @param o Nastavovana oblast
*/
public static void set(IHybaci ih, Oblast o)
{
SpravcePlatna SP = SpravcePlatna.getInstance();
SP.nekresli(); {
ih.setPozice(o.x, o.y);
ih.setRozmer(o.sirka, o.vyska);
} SP.vratKresli();
}
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori oblast se zadanym umistenim a rozmery.
*
* @param x Vodorovna souradnice oblasti, tj. jejiho leveho horniho rohu.
* @param y Svisla souradnice oblasti, tj. jejiho leveho horniho rohu.
* @param sirka Sirka oblasti.
* @param vyska Vyska oblasti.
*/
public Oblast( int x, int y, int sirka, int vyska )
{
this.x = x;
this.y = y;
this.sirka = sirka;
this.vyska = vyska;
}
/***************************************************************************
* Vytvori oblast se zadanym umistenim a rozmery.
*
* @param pozice Pozice oblasti, tj pozice jejiho leveho horniho rohu.
* @param rozmer Rozmer vytvarene oblasti.
*/
public Oblast( Pozice pozice, Rozmer rozmer )
{
this( pozice.x, pozice.y, rozmer.sirka, rozmer.vyska );
}
//== ABSTRAKTNI METODY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Vrati pozici dane oblasti.
*
* @return Pozice dane oblasti
*/
public Pozice getPozice()
{
return new Pozice ( x, y );
}
/***************************************************************************
* Vrati rozmer dane oblasti.
*
* @return Rozmer dane oblasti
*/
public Rozmer getRozmer()
{
return new Rozmer ( sirka, vyska );
}
/***************************************************************************
* Vrati velikost sirky oblasti.
*
* @return Sirka oblasti.
*/
public int getSirka()
{
return sirka;
}
/***************************************************************************
* Vrati velikost vysky oblasti.
*
* @return Vyska oblasti.
*/
public int getVyska()
{
return vyska;
}
/***************************************************************************
* Vrati hodnotu vodorovne souradnice dane oblasti.
*
* @return Pozadovana souradnice.
*/
public int getX()
{
return x;
}
/***************************************************************************
* Vrati hodnotu svisle souradnice dane oblasti.
*
* @return Pozadovana souradnice.
*/
public int getY()
{
return y;
}
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
/***************************************************************************
* Vraci textovou reprezentaci dane instance
* pouzivanou predevsim k ladicim ucelum.
*
* @return Pozadovana textova reprezentace.
*/
@Override
public String toString()
{
return "Oblast[x=" + x + ",y=" + y + ",sirka=" +
sirka + ",vyska=" + vyska + "]";
}
/***************************************************************************
* Vrati informaci o tom, reprezentuje-li zadana instance stejnou oblast
* jako objekt zadany jako parametr.
*
* @param objekt Objekt, s nimz je dana instance porovnavana
* @return {@code true} reprezentuje-li objekt stejnou oblast,
* jinak {@code false}
*/
@Override
public boolean equals(Object objekt) {
if( ! (objekt instanceof Oblast) ) {
return false; //==========>
}
Oblast oblast = (Oblast)objekt;
return (oblast.x == x ) && (oblast.y == y ) &&
(oblast.sirka == sirka) && (oblast.vyska == vyska);
}
/***************************************************************************
*
* @return
*/
@Override
public int hashCode() {
if( hashCode == Integer.MIN_VALUE ) {
hashCode = 7;
hashCode = 59 * hashCode + this.x;
hashCode = 59 * hashCode + this.y;
hashCode = 59 * hashCode + this.sirka;
hashCode = 59 * hashCode + this.vyska;
}
return hashCode;
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Pozice.java
package knihovna;
/*******************************************************************************
* Trida Pozice slouzi jako prepravka uchovavajici informace o pozici objektu.
* Proto jsou jeji atributy deklarovany jako verejne konstanty.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Pozice
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Vodorovna souradnice dane pozice. */
public final int x;
/** Svisla souradnice dane pozice. */
public final int y;
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori instanci se zadanymi souradnicemi.
*
* @param x Vodorovna souradnice.
* @param y Svisla souradnice.
*/
public Pozice( int x, int y )
{
this.x = x;
this.y = y;
}
/***************************************************************************
* Vytvori instanci, ktera je kopii zadane instance.
*
* @param pozice Referencni pozice.
*/
public Pozice( Pozice pozice )
{
this( pozice.x, pozice.y );
}
//== ABSTRAKTNI METODY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Vrati hodnotu vodorovne souradnice dane pozice.
*
* @return Pozadovana souradnice.
*/
public int getX()
{
return x;
}
/***************************************************************************
* Vrati hodnotu svisle souradnice dane pozice.
*
* @return Pozadovana souradnice.
*/
public int getY()
{
return y;
}
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
/***************************************************************************
* Vrati informaci o tom, reprezentuje-li zadana instance stejnou pozici
* jako objekt zadany jako parametr.
*
* @param o Objekt, s nimz je dana instance porovnavana
* @return {@code true} reprezentuje-li objekt stejnou pozici,
* jinak {@code false}
*/
@Override
public boolean equals( Object o )
{
if( ! (o instanceof Pozice) ) {
return false; //==========>
}
Pozice p = (Pozice)o;
return (p.x == x) && (p.y == y);
}
/***************************************************************************
* Vrati hodnotu hes-kodu dane instance.
*
* @return Hodnota hes-kodu
*/
@Override
public int hashCode()
{
//Nema smysl si jej pamatovat,
//protoze nemame zarucenou nemennost instance
return 17 + 37*(37*x + y);
}
/***************************************************************************
* Vraci textovou reprezentaci dane instance
* pouzivanou predevsim k ladicim ucelum.
*
* @return Pozadovana textova reprezentace.
*/
@Override
public String toString()
{
return "Pozice[x=" + x + ",y=" + y + "]";
}
/***************************************************************************
* Vrati vzdalenost od teto pozice k pozici zadane jako parametr.
*
* @param p Pozice, k niz se zjistuje vzdalenost
* @return Zjistena vzdalenost
*/
public double vzdalenostK( Pozice p )
{
return Math.hypot( x-p.x, y-p.y );
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Presouvac.java
package knihovna;
/*******************************************************************************
* Trida Presouvac slouzi k pohybu s instancemi trid
* implementujicich rozhrani IPosuvny.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Presouvac
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Tento atribut je tu pouze pro zjednoduseni psani. */
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
/** Oocet milisekund mezi dvema prekreslenimi objektu. */
private static final int PERIODA = 50;
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Pocet vytvorenych instanci */
private static int pocet = 0;
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Nazev sestavajici z nazvu tridy a poradi instance */
private final String nazev;
//== PROMENNE ATRIBUTY INSTANCI ================================================
/** Specifikuje rychlost posunu objektu danym posunovacem. */
private int rychlost;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori presouvace, ktery bude presouvat objekty rychlosti 1.
*/
public Presouvac()
{
this( 1 );
}
/***************************************************************************
* Vytvori presouvace, ktery bude presouvat objekty zadanou rychlosti.
*
* @param rychlost Rychlost, kterou bude presouvac pohybovat
* se sverenymi objekty.
*/
public Presouvac( int rychlost )
{
if( rychlost <= 0 ) {
throw new IllegalArgumentException(
"Zadana rychlost musi byt nezaporna!");
}
this.rychlost = rychlost;
this.nazev = getClass().getName() + "(ID=" + ++pocet +
",rychlost=" + rychlost + ")";
}
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Metoda prevadi instanci na retezec -
* pouziva se vetsinou pro ucely ladeni.
* Mela by ji definovat kazda trida a uvest v ni
* vsechny potrebne informace o vnitrnim stavu instance.
*
* @return Retezec informujici o vnitrnim stavu instance
*/
@Override
public String toString()
{
return nazev;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
/***************************************************************************
* Presune zadany objekt o pozadovany pocet bodu.
*
* @param objekt Presouvany objekt
* @param doprava Pocet bodu, o nez se objekt presune doprava
* @param dolu Pocet bodu, o nez se objekt presune dolu
*/
public void presunO( IPosuvny objekt, int doprava, int dolu )
{
double vzdalenost = Math.sqrt(doprava*doprava + dolu*dolu);
int kroku = (int)(vzdalenost / rychlost);
double dx = (doprava+.4) / kroku;
double dy = (dolu +.4) / kroku;
Pozice p = objekt.getPozice();
double x = p.getX() + .4;
double y = p.getY() + .4;
for(int i=kroku; i > 0; i-- ) {
x = x + dx;
y = y + dy;
SP.nekresli(); {
objekt.setPozice( (int)x, (int)y );
SP.prekresli();
} SP.vratKresli();
IO.cekej(PERIODA);
}
}
/***************************************************************************
* Presune zadany objekt o pozadovany pocet bodu.
*
* @param objekt Presouvany objekt
* @param posun Pocet bodu, o nez se objekt presune doprava a dolu
* ulozeny v prepravce
*/
public void presunO( IPosuvny objekt, Pozice posun )
{
presunO( objekt, posun.x, posun.y );
}
/***************************************************************************
* Presune zadany objekt do pozadovane pozice.
*
* @param objekt Presouvany objekt
* @param x x-ova souradnice pozadovane cilove pozice
* @param y y-ova souradnice pozadovane cilove pozice
*/
public void presunNa( IPosuvny objekt, int x, int y )
{
Pozice p = objekt.getPozice();
presunO( objekt, x-p.x, y-p.y );
}
/***************************************************************************
* Presune zadany objekt do pozadovane pozice.
*
* @param objekt Presouvany objekt
* @param pozice Pozadovane cilove pozice.
*/
public void presunNa( IPosuvny objekt, Pozice pozice )
{
presunNa( objekt, pozice.x, pozice.y );
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Rozmer.java
package knihovna;
/*******************************************************************************
* Trida Rozmer slouzi jako prepravka k uchovavani informaci o rozmeru objektu.
* Proto jsou jeji atributy deklarovany jako verejne konstanty.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Rozmer
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Sirka objektu. */
public final int sirka;
/** Vyska objektu. */
public final int vyska;
//== PROMENNE ATRIBUTY INSTANCI ================================================
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori instanci se zadanymi rozmery.
*
* @param sirka Sirka objektu.
* @param vyska Vyska objektu.
*/
public Rozmer( int sirka, int vyska )
{
this.sirka = sirka;
this.vyska = vyska;
}
//== ABSTRAKTNI METODY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Vrati velikost sirky objektu.
*
* @return Sirka objektu.
*/
public int getSirka()
{
return sirka;
}
/***************************************************************************
* Vrati velikost vysky objektu.
*
* @return Vyska objektu.
*/
public int getVyska()
{
return vyska;
}
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
/***************************************************************************
* Vrati informaci o tom, reprezentuje-li zadana instance stejny rozmer
* jako objekt zadany jako parametr.
*
* @param o Objekt, s nimz je dana instance porovnavana
* @return {@code true} reprezentuje-li objekt stejny rozmer,
* jinak {@code false}
*/
@Override
public boolean equals( Object o )
{
if( ! (o instanceof Rozmer) ) {
return false; //==========>
}
Rozmer p = (Rozmer)o;
return (p.sirka == sirka) && (p.vyska == vyska);
}
/***************************************************************************
* Vrati hodnotu hes-kodu dane instance.
*
* @return Hodnota hes-kodu
*/
@Override
public int hashCode()
{
//Nema smvyskasl si jej pamatovat,
//protoze nemame zarucenou nemennost instance
return 17 + 37*(37*sirka + vyska);
}
/***************************************************************************
* Vraci textovou reprezentaci dane instance
* pouzivanou predevsim k ladicim ucelum.
*
* @return Pozadovana textova reprezentace.
*/
@Override
public String toString()
{
return "Rozmer[sirka=" + sirka + ", vyska=" + vyska + "]";
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Smer8.java
package knihovna;
import java.util.HashMap;
import java.util.Map;
//Import pro test
//import java.util.ArrayList;
//import java.util.List;
/*******************************************************************************
* Trida {@code Smer8} slouzi jako vyctovy typ pro 8 hlavnich svetovych stran.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public enum Smer8
{
//== HODNOTY VYCTOVEHO TYPU ====================================================
VYCHOD ( 1, 0, "S" ),
SEVEROVYCHOD( 1, -1, "SV" ),
SEVER ( 0, -1, "S" ),
SEVEROZAPAD ( -1, -1, "SZ" ),
ZAPAD ( -1, 0, "Z" ),
JIHOZAPAD ( -1, 1, "JZ" ),
JIH ( 0, 1, "J" ),
JIHOVYCHOD ( 1, 1, "JV" ),
ZADNY ( 0, 0, "@" ),
;
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Celkovy pocet definovanych smeru. */
public static final int SMERU = 9;
/** Maska pro deleni modulo. */
private static final int MASKA = 7;
/** Odmocnina z jedne poloviny. */
private static final double SQR = Math.sqrt( 0.5 );
/** Vsechny pouzitelne nazvy smeru. */
private static final Map<String,Smer8> nazvy =
new HashMap<String,Smer8>( SMERU*3 );
/** Vektor jednotlivych smeru. */
private static final Smer8[] SMERY = values();
//Inicializace statickych atributu je nerealizovatelna pred
//definici jednotlivych hodnot ==> je ji proto potreba realizovat dodatecne
static
{
for( Smer8 s : SMERY )
{
nazvy.put( s.prepravka.zkratka, s );
nazvy.put( s.name(), s );
String bhc = IO.odhackuj( s.name() ); //bhc = bez hacku a carek
if( ! s.name().equals( bhc ) ) {
nazvy.put(bhc, s);
}
s.prepravka = null; //Prepravka uz nebude potreba
}
}
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Priznak povoleni operaci se smerem ZADNY. */
private static boolean zadnyZakazan = false;
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Velikost zmeny prislusne slozky souradnic po presunu
* na sousedni policko v danem smeru. */
private final int dx, dy;
//== PROMENNE ATRIBUTY INSTANCI ================================================
/**************************************************************************
* Prepravka slouzi k docasnemu uchovani hodnot parametru konstruktoru
* do doby, nez jimi budou moci byt inicializovany staticke atributy.
*/
private static class Prepravka
{
String zkratka;
}
Prepravka prepravka;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
/***************************************************************************
* Nastavi, zda budou povoleny operace se smerem zadny.
* Nejsou-li operace povoleny, vyhazuji u tohoto smeru vyjimku
* {@link java.lang.iIllegalStateException}.
* Jsou-li operace povoleny, pak objekt natoceny do smeru {@link #ZADNY}
* zustava v romto "smeru" po jakemkoliv otoceni
* a pri jakekmkoliv presunu zustava na miste.
* @param zakazat {@code true} maji-li se operace zakazat,
* {@code false} maji-li se povolit
* @return Puvodni nastaveni tohoto priznaku
*/
public static boolean zakazatZadny(boolean zakazat) {
boolean puvodni = ! zadnyZakazan;
zadnyZakazan = zakazat;
return puvodni;
}
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/**************************************************************************
* Vrati smer se zadanym nazvem nebo zkratkou.
* Bohuzel neni mozno pouzit definovat jako valueOf(),
* protoze tuto metodu definuje prekladac v teto tride
* takze ji neni mozno prekryt vlastni verzi.
*
* @param nazev Nazev pozadovaneho smeru nebo jeho zkratka
* @return Pozadovany smer
*/
public static Smer8 getSmer8( String nazev )
{
Smer8 ret = nazvy.get(nazev.toUpperCase() );
if( ret == null ) {
throw new IllegalArgumentException("Nepovoleny nazev smeru");
}
return ret;
}
/**************************************************************************
* Vytvori novy smer a zapamatuje si zkratku jeho nazvu
* spolu se zmenami souradnic pri pohybu v danem smeru.
*
* @param dx Zmena vodorovne souradnice
* pri presunu na sousedni policko v danem smeru.
* @param dy Zmena svisle souradnice
* pri presunu na sousedni policko v danem smeru.
* @param zkratka Jedno- ci dvoj-pismenna zkratka oznacujici dany smer.
*/
private Smer8( int dx, int dy, String zkratka )
{
this.dx = dx;
this.dy = dy;
prepravka = new Prepravka();
prepravka.zkratka = zkratka;
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
//== VLASTNI METODY INSTANCI ===================================================
/**************************************************************************
* Vrati pozici sousedniho policka v danem smeru.
*
* @param pozice Pozice stavajiciho policka
*
* @return Pozice sousedniho policka v danem smeru
*/
public Pozice dalsiPozice( Pozice pozice )
{
overPlatny();
return new Pozice( pozice.getX() + dx,
pozice.getY() + dy );
}
/**************************************************************************
* Vrati x-vou souradnici sousedniho policka v danem smeru.
*
* @param x x-ova souradnice stavajiciho policka.
* @return x-ova souradnice policka po presunu o jedno pole v danem smeru.
*/
public int dalsiX( int x )
{
overPlatny();
return x + dx;
}
/**************************************************************************
* Vrati x-ovou (vodorovnou) souradnici policka
* vzdaleneho v danem smeru o zadanou vzdalenost.
*
* @param x x-ova souradnice stavajiciho policka
* @param vzdalenost Vzdalenost policka v danem smeru
* @return x-ova souradnice vzdaleneho policka
*/
public double dalsiX( int x, int vzdalenost )
{
overPlatny();
if( (dx != 0) && (dy != 0) ) {
return x + SQR*dx*vzdalenost;
} else {
return x + dx*vzdalenost;
}
}
/**************************************************************************
* Vrati y-vou souradnici sousedniho policka v danem smeru.
*
* @param y y-ova souradnice stavajiciho policka
*
* @return y-ova souradnice sousedniho policka v danem smeru
*/
public int dalsiY( int y )
{
overPlatny();
return y + dy;
}
/**************************************************************************
* Vrati y-ovou (svislou) souradnici policka
* vzdaleneho v danem smeru o zadanou vzdalenost.
*
* @param y x-ova souradnice stavajiciho policka
* @param vzdalenost Vzdalenost policka v danem smeru
* @return y-ova souradnice vzdaleneho policka
*/
public double dalsiY( int y, int vzdalenost )
{
overPlatny();
if( (dx != 0) && (dy != 0) ) {
return y + SQR*dy*vzdalenost;
} else {
return y + dy*vzdalenost;
}
}
/**************************************************************************
* Vrati zmenu x-ove souradnice pri presunu na sousedni pole v danem smeru.
*
* @return Zmena x-ove souradnice pri presunu o jedno pole v danem smeru
*/
public int dx()
{
overPlatny();
return dx;
}
/**************************************************************************
* Vrati zmenu y-ove souradnice pri presunu na sousedni pole v danem smeru.
*
* @return Zmena y-ove souradnice pri presunu o jedno pole v danem smeru
*/
public int dy()
{
overPlatny();
return dy;
}
/**************************************************************************
* Vrati smer otoceny o 45\u00b0 vlevo.
*
* @return Smer objektu po vyplneni prikazu nalevo vpric.
*/
public Smer8 nalevoVpric()
{
overPlatny();
if( this == ZADNY ) {
return this;
} else {
return SMERY[MASKA & (1+ordinal())];
}
}
/**************************************************************************
* Vrati smer otoceny o 45\u00b0 vpravo.
*
* @return Smer objektu po vyplneni prikazu napravo vpric.
*/
public Smer8 napravoVpric()
{
overPlatny();
if( this == ZADNY ) {
return this;
} else {
return SMERY[MASKA & (-1+ordinal())];
}
}
/**************************************************************************
* Vrati smer otoceny o 90\u00b0 vlevo.
*
* @return Smer objektu po vyplneni prikazu vlevo v bok.
*/
public Smer8 vlevoVbok()
{
overPlatny();
if( this == ZADNY ) {
return this;
} else {
return SMERY[MASKA & (2+ordinal())];
}
}
/**************************************************************************
* Vrati smer otoceny o 90\u00b0 vpravo.
*
* @return Smer objektu po vyplneni prikazu vpravo v bok
*/
public Smer8 vpravoVbok()
{
overPlatny();
if( this == ZADNY ) {
return this;
} else {
return SMERY[MASKA & (-2+ordinal())];
}
}
/**************************************************************************
* Vrati smer otoceny o 180\u00b0.
*
* @return Smer objektu po vyplneni prikazu celem vzad.
*/
public Smer8 celemVzad()
{
overPlatny();
if( this == ZADNY ) {
return this;
} else {
return SMERY[MASKA & (4+ordinal())];
}
}
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
/***************************************************************************
* Overi, ze se nejedna o operaci,
* kterou neni mozno provadet se smerem ZADNY.
*
* @throws IllegalStateException - Jedna se o operaci zakazanou
* pro smer ZADNY.
*/
private void overPlatny()
{
if( zadnyZakazan && (this == ZADNY) ) {
throw new IllegalStateException(
"Operaci neni mozno provadet nad smerem ZADNY" );
}
}
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
////+ main
////Potrebuje import
////import java.util.ArrayList;
////import java.util.List;
//
// public static void main( String[] args )
// {
// List smery = new ArrayList();
// for( Smer8 s : Smer8.values() )
// {
// System.out.println(s + " - vlevo:" + s.vlevoVbok() +
// " - vpravo:" + s.vpravoVbok() +
// " - vzad:" + s.celemVzad() +
// " - nale:" + s.nalevoVpric() +
// " - napra:" + s.napravoVpric());
// System.out.println(" dx:" + s.dx() +
// " - dy:" + s.dy() +
// " - dalsiX(0):" + s.dalsiX(0) +
// " - dalsiY(0):" + s.dalsiY(0) +
// " - dalsiX(0,10):" + s.dalsiX(0,10) +
// " - dalsiY(0,10):" + s.dalsiY(0,10) );
// }
// }
////- main
}
Raw
Displej_projekt_src_knihovna_SpravcePlatna.java
package knihovna;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyListener;
import java.awt.event.MouseListener;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.List;
/*******************************************************************************
* Trida <b><code>SpravcePlatna</code></b> slouzi k jednoduchemu kresleni
* na virtualni platno a pripadne nasledne animaci nakreslenych obrazku.
* </p><p>
* Trida neposkytuje verejny konstruktor, protoze chce, aby jeji instance
* byla jedinacek, tj. aby se vsechno kreslilo na jedno a to same platno.
* Jedinym zpusobem, jak ziskat odkaz na instanci tridy
* <code>SpravcePlatna</code>,
* je volani jeji staticke metody <code>getInstance()</code>.
* </p><p>
* Trida <code>SpravcePlatna</code> funguje jako manazer, ktery dohlizi
* na to, aby se po zmene zobrazeni nektereho z tvaru vsechny ostatni tvary
* radne prekreslily, aby byly spravne zachyceny vsechny prekryvy
* a aby se pri pohybu jednotlive obrazce vzajemne neodmazavaly.
* Aby vse spravne fungovalo, je mozno pouzit jeden ze dvou pristupu:</p>
* <ul>
* <li>Manazer bude obsah platna prekreslovat
* <b>v pravidelnych intervalech</b>
* bez ohledu na to, jestli se na nem udala nejaka zmena ci ne.
* <ul><li>
* <b>Vyhodou</b> tohoto pristupu je, ze se zobrazovane objekty
* nemusi starat o to, aby se manazer dozvedel, ze se jejich stav zmenil.
* </li><li>
* <b>Neyhodou</b> tohoto pristupu je naopak to, ze manazer
* spotrebovava na neustale prekreslovani jistou cast vykonu
* procesoru, coz muze u pomalejsich pocitacu pusobit problemy.
* <br>&nbsp;</li></ul></li>
* <li>Manazer prekresluje platno <b>pouze na vyslovne pozadani</b>.
* <ul><li>
* <b>Vyhodou</b> tohoto pristupu je uspora spotrebovaneho vykonu
* pocitace v obdobi, kdy se na platne nic nedeje.
* </li><li>
* <b>Nevyhodou</b> tohoto pristupu je naopak to, ze kreslene
* objekty musi na kazdou zmenu sveho stavu upozornit manazera,
* aby vedel, zed ma platno prekreslit.
* </li>
* </ul><p>
* Trida <code>SpravcePlatna</code> poziva druhou z uvedenych strategii,
* tj. <b>prekresluje platno pouze na pozadani</b>.
* </p><p>
* Obrazec, ktery chce byt zobrazovan na platne, se musi nejprve prihlasit
* u instance tridy <code>SpravcePlatna</code>, aby jej tato zaradila
* mezi spravovane obrazce (sada metod <code>pridej&hellip;</code>).
* Prihlasit se vsak mohou pouze instance trid, ktere implementuji
* rozhrani <code>IKresleny</code>.
* </p><p>
* Neprihlaseny obrazec nema sanci byti zobrazen, protoze na platno
* se muze zobrazit pouze za pomoci kreslitka, jez muze ziskat jedine od
* instance tridy <code>SpravcePlatna</code>, ale ta je poskytuje pouze
* instancim, ktere se prihlasily do jeji spravy.
* </p><p>
* Obrazec, ktery jiz dale nema byt kreslen, se muze odhlasit zavolanim
* metody <code>odstran(IKresleny)</code>.Zavolanim metody
* <code>odstranVse()</code> se ze seznamu spravovanych (a tim i z platna)
* odstrani vsechny vykreslovane obrazce.
* </p><p>
* Efektivitu vykreslovani je mozne ovlivnit volanim metody
* <code>nekresli()</code>, ktera pozastavi prekreslovani platna po nahlasenych
* zmenach. Jeji volani je vyhodne napr. v situaci, kdy je treba vykreslit
* obrazec slozeny z rady mensich obrazcu a bylo by nevhodne prekreslovat
* platno po vykresleni kazdeho z nich.
* </p><p>
* Do puvodniho stavu prevedeme platno volanim metody <code>vratKresli()</code>,
* ktera vrati vykreslovani do stavu pred poslednim volanim metody
* <code>nekresli()</code>. Nemuzec se tedy stat, ze by se pri zavolani metody
* <code>nekresli()</code> v situaci, kdy je jiz vykreslovani pozastaveno,
* zacalo po nasledem zavolani <code>vratKresli()</code> hned vykreslovat.
* Po dvou volanich <code>vratKresli()</code> se zacne vykreslovat az po
* dvou zavolanich <code>vratKresli()</code>.
* </p><p>
* Proto platno pouze zadame, aby se vratilo do toho kresliciho stavu,
* ve kterem bylo v okamziku, kdy jsme je naposledy zadali o to,
* aby se prestalo prekreslovat. Nemuze se tedy stat, ze by se pri zavolani
* metody <code>nekresli()</code> v situaci, kdy je jiz vykreslovani
* pozastaveno, zacalo po naslednem zavolani <code>vratKresli()</code> hned
* vykreslovat.
* </p><p>
* Kazde zavolani metody <code>nekresli()</code> musi byt doplneno
* odpovidajicim volanim <code>vratKresli()</code>. Teprve kdyz posledni
* <code>vratKresli()</code> odvola prvni <code>nekresli()</code>, bude
* prekreslovani opet obnoveno.
* </p>
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public final class SpravcePlatna
{
////%A+ =999%
// static {
// msgS("SpravcePlatna - class constructor");
// }
// {
// msgS("SpravcePlatna - deklarace atributu instance");
// }
////%A-
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Titulek okna aktivniho platna. */
private static final String TITULEK_0 = "Platno ovladane spravcem";
/** Pocatecni polickova sirka aktivni plochy platna. */
private static final int SIRKA_0 = 6;
/** Pocatecni polickova vyska aktivni plochy platna. */
private static final int VYSKA_0 = 6;
/** Pocatecni barva pozadi platna. */
private static final Barva POZADI_0 = Barva.KREMOVA;
/** Pocatecni barva car mrizky. */
private static final Barva BARVA_CAR_0 = Barva.CERNA;
/** Implicitni roztec ctvercove site. */
private static final int KROK_0 = 50;
/** Maximalni povolena velikost roztece ctvercove site. */
private static final int MAX_KROK = 200;
//== PROMENNE ATRIBUTY TRIDY ===================================================
/** Jedina instance tridy. */
private static volatile SpravcePlatna SP;
//== STATICKY INICIALIZACNI BLOK - STATICKY KONSTRUKTOR ========================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
/** Aplikacni okno animacniho platna. */
private final JFrame okno;
/** Instance lokalni tridy, ktera je zrizena proto, aby odstinila
* metody sveho rodice JPanel. */
private final JPanel platno;
/** Seznam zobrazovanych predmetu. */
private final List<IKresleny> predmety = new ArrayList<IKresleny>();
//== PROMENNE ATRIBUTY INSTANCI ================================================
//Z venku neovlivnitelne Atributy pro zobrazeni platna v aplikacnim okne
/** Vse se kresli na obraz - ten se snadneji prekresli. */
private Image obrazPlatna;
/** Kreslitko ziskane od obrazu platna, na nejz se vlastne kresli. */
private Kreslitko kreslitko;
/** Semafor branici prilis castemu prekreslovani. Prekresluje se pouze
* je-li ==0. Nesmi byt <0. */
private int nekreslit = 0;
/** Priznak toho, ze kresleni prave probiha,
* takze vypinani nefunguje. */
private boolean kreslim = false;
/** Cary zobrazujici na plante mrizku. */
private Cara[] vodorovna, svisla;
//Primo ovlivnitelne atributy
/** Roztec ctvercove site. */
private int krok = KROK_0;
/** Zobrazuje-li se mrizka. */
private boolean mrizka = true;
/** Barva pozadi platna. */
private Barva barvaPozadi = POZADI_0;
/** Barva car mrizky. */
private Barva barvaCar = BARVA_CAR_0;
/** Sirka aktivni plochy platna v udavana v polich. */
private int sloupcu = SIRKA_0;
/** Vyska aktivni plochy platna v udavana v polich. */
private int radku = VYSKA_0;
/** Sirka aktivni plochy platna v bodech. */
private int sirkaBodu = SIRKA_0 * krok;
/** Vyska aktivni plochy platna v bodech. */
private int vyskaBodu = VYSKA_0 * krok;
/** Zda se maji prizpusobivi upozornovat na zmeny rozmeru pole. */
private boolean hlasitZmenyRozmeru = true;
/** Zda je mozno menit velikost kroku. */
private Object vlastnikPovoleniZmenyKroku = null;
/** Pozice platna na obrazovace - pri pouzivani vice obrazovek
* je obcas treba ji po zviditelneni obnovit. */
Point pozicePlatna;
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Metoda umoznujici ziskat odkaz na instanci spravce platna
* a pripadne zviditelnit jeho aplikacni okno.
* Vraci vsak pokazde odkaz na stejnou instanci,
* protoze instance platna je jedinacek.
* <p>
* Pokud instance pri volani metody jeste neexistuje,
* metoda instanci vytvori.</p>
*
* @return Instance tridy {@code SpravcePlatna}
*/
public static SpravcePlatna getInstance()
{
return getInstance(true);
}
/***************************************************************************
* Metoda umoznujici ziskat odkaz na instanci spravce platna
* a soucasne nastavit, zda ma byt jeho aplikacni okno viditelne.
* Vraci vsak pokazde odkaz na stejnou instanci,
* protoze instance platna je jedinacek.
* <p>
* Pokud instance pri volani metody jeste neexistuje,
* metoda instanci vytvori.</p>
*
* @param viditelny Ma-li se zajistit viditelnost instance;
* {@code false} aktualne nastavenou viditelnost nemeni
* @return Instance tridy {@code SpravcePlatna}
*/
public static SpravcePlatna getInstance(boolean viditelny)
{
////%A+ =999%
// msgS("getInstance()");
////%A-
if (SP == null) {
synchronized(SpravcePlatna.class) {
if (SP == null) {
inicializuj();
}
}
}
if (viditelny) {
SP.setViditelne(true);
}
////%A+ =999%
// msgF("getInstance()");
////%A-
return SP;
}
/***************************************************************************
* Vytvori instanci tridy - jedinacka => je volan pouze jednou.
*/
@SuppressWarnings("serial")
private SpravcePlatna()
{
////%A+ =999%
// msgS("SpravcePlatna - Konstruktor - telo");
////%A-
okno = new JFrame();
okno.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
////%A+ =999%
// msg("SpravcePlatna - Konstruktor - Okno pripraveno");
////%A-
platno = new JPanel()
{ /** Overrides parent's abstract method. */
@Override
public void paintComponent(Graphics g)
{
g.drawImage(obrazPlatna, 0, 0, null);
}
};
////%A+ =999%
// msg("SpravcePlatna - Konstruktor - Platno pripraveno");
////%A-
okno.setContentPane(platno);
////%A+ =999%
// msgF("SpravcePlatna - Konstruktor - telo");
////%A-
}
//== ABSTRAKTNI METODY =========================================================
//== PRISTUPOVE METODY VLASTNOSTI INSTANCI =====================================
/***************************************************************************
* Nastavi rozmer platna zadanim bodove velikosti policka a
* poctu policek ve vodorovnem a svislem smeru.
* Pri velikosti policka = 1 se vypina zobrazovani mrizky.
*
* @param krok Nova bodova velikost policka
* @param pSirka Novy pocet policek vodorovne
* @param pVyska Novy pocet policek svisle
*/
public void setKrokRozmer(int krok, int pSirka, int pVyska)
{
setKrokRozmer(krok, pSirka, pVyska, null);
}
/***************************************************************************
* Nastavi rozmer platna zadanim bodove velikosti policka a
* poctu policek ve vodorovnem a svislem smeru.
* Pri velikosti policka = 1 se vypina zobrazovani mrizky.
*
* @param krok Nova bodova velikost policka
* @param pSirka Novy pocet policek vodorovne
* @param pVyska Novy pocet policek svisle
* @param menic Objekt, ktery zada o zmenu rozmeru. Jakmile je jednou
* tento objekt nastaven, nesmi jiz rozmer platna
* menit nikdo jiny.
*/
public
synchronized void setKrokRozmer(final int krok,
final int pSirka, final int pVyska,
Object menic)
{
////%A+ =999%
// msgS("setKrokRozmer");
////%A-
setKrokRozmer_OverParametry(krok, pSirka, pVyska, menic);
nekresli(); {
int stary = this.krok;
invokeAndWait(new Runnable() {
@Override
public void run()
{
setKrokRozmerInterni(krok, pSirka, pVyska);
}
}, "setKrokRozmerInterni from setKrokRozmer");
pripravCary();
////%A+ >135
// obvolejPrizpusobive(stary, krok);
////%A-
setViditelne_Pockam();
} vratKresli();
////%A+ =999%
// msgF("setKrokRozmer");
////%A-
}
/***************************************************************************
* Vrati vzdalenost car mrizky = bodovou velikost policka.
*
* @return Bodova velikost policka
*/
public int getKrok()
{
return krok;
}
/***************************************************************************
* Nastavi vzdalenost car mrizky = bodovou velikost policka.
* Pri velikosti policka = 1 se vypina zobrazovani mrizky.
*
* @param velikost Nova bodova velikost policka
*/
public
void setKrok(int velikost)
{
setKrokRozmer(velikost, sloupcu, radku);
}
/***************************************************************************
* Vrati pocet sloupcu platna, tj. jeho polickovou sirku.
*
* @return Aktualni polickova sirka platna (pocet policek vodorovne)
*/
public int getSloupcu()
{
return sloupcu;
}
/***************************************************************************
* Vrati bodovou sirku platna.
*
* @return Aktualni bodova sirka platna (pocet bodu vodorovne)
*/
public
int getBsirka()
{
return sirkaBodu;
}
/***************************************************************************
* Vrati pocet radku platna, tj. jeho polickovou vysku.
*
* @return Aktualni polickova vyska platna (pocet policek svisle)
*/
public int getRadku()
{
return radku;
}
/***************************************************************************
* Vrati bodovou vysku platna.
*
* @return Aktualni bodova vyska platna (pocet bodu svisle)
*/
public
int getBVyska()
{
return vyskaBodu;
}
/***************************************************************************
* Vrati polickovy rozmer platna, tj. sirku a vysku v polich.
*
* @return Aktualni polickovy rozmer platna
*/
public Rozmer getRozmer()
{
return new Rozmer(sloupcu, radku);
}
/***************************************************************************
* Nastavi rozmer platna zadanim jeho polickove vysky a sirky.
*
* @param sloupcu Novy pocet policek vodorovne
* @param radku Novy pocet policek svisle
*/
public
void setRozmer(int sloupcu, int radku)
{
setKrokRozmer(krok, sloupcu, radku);
}
/***************************************************************************
* Nastavi rozmer platna zadanim jeho polickove vysky a sirky.
*
* @param rozmer Zadavany rozmer v poctu policek
*/
public void setRozmer(Rozmer rozmer)
{
setRozmer(rozmer.sirka, rozmer.vyska);
}
/***************************************************************************
* Vrati informaci o tom, je-li zobrazovana mrizka.
*
* @return Mrizka je zobrazovana = true, neni zobrazovana = false.
*/
public boolean isMrizka()
{
return mrizka;
}
/***************************************************************************
* V zavislosti na hodnte parametru nastavi nebo potlaci
* zobrazovani car mrizky.
*
* @param zobrazit Jestli mrizku zobrazovat.
*/
public synchronized void setMrizka(boolean zobrazit)
{
mrizka = zobrazit;
pripravCary();
prekresli();
}
/***************************************************************************
* Poskytuje informaci o aktualni viditelnosti okna.
*
* @return Je-li okno viditelne, vraci <b>true</b>, jinak vraci <b>false</b>
*/
public
boolean isViditelne()
{
return okno.isVisible();
}
/***************************************************************************
* V zavislosti na hodnote sveho parametru
* nastavi nebo potlaci viditelnost platna na displeji.
*
* @param viditelne logicka hodnota pozadovane viditelnost (true=viditelne)
*/
public
synchronized void setViditelne(final boolean viditelne)
{
boolean prekresleno = false;
boolean zmena = (isViditelne() != viditelne);
if (! zmena) {
return; //==========>
}
if (! viditelne) {
okno.setVisible(false);
return; //==========>
}
////%A+ =999%
// msgS("setViditelne");
////%A-
//Mame dosud neviditelne okno zobrazit
pozicePlatna = okno.getLocation();
if (EventQueue.isDispatchThread()) {
setViditelneInterni(viditelne);
}
else {
Runnable runnable = new Runnable()
{
@Override
public void run()
{
////%A+ =999%
// msgS("run() from setViditelne");
////%A-
setViditelneInterni(viditelne);
////%A+ =999%
// msgF("run() from setViditelne");
////%A-
}
};
EventQueue.invokeLater(runnable);
}
////%A+ =999%
// msgF("setViditelne");
////%A-
}
/***************************************************************************
* Vrati aktualni barvu pozadi.
*
* @return Nastavena barva pozadi
*/
public Barva getBarvaPozadi()
{
return barvaPozadi;
}
/***************************************************************************
* Nastavi pro platno barvu pozadi.
*
* @param barva Nastavovana barva pozadi
*/
public synchronized void setBarvaPozadi(Barva barva)
{
barvaPozadi = barva;
kreslitko.setPozadi(barvaPozadi);
prekresli();
}
/***************************************************************************
* Pomocna metoda pro ucely ladeni aby bylo mozno zkontrolovat,
* ze na konci metody ma semafor stejnou hodnotu, jako mel na pocatku.
*
* @return Stav vnitrniho semaforu: >0 - nebude se kreslit,<br>
* ==0 - kresli se,<br>
* <0 - chyba
*/
public
int getNekresli()
{
return nekreslit;
}
/***************************************************************************
* Vrati aktualni nazev v titulkove liste okna platna.
*
* @return Aktualni nazev okna
*/
public String getNazev()
{
return okno.getTitle();
}
/***************************************************************************
* Nastavi nazev v titulkove liste okna platna.
*
* @param nazev Nastavovany nazev
*/
public void setNazev(String nazev)
{
okno.setTitle(nazev);
}
/***************************************************************************
* Vrati vodorovnou souradnici aplikacniho okna platna.
*
* @return Pozice leveho horniho rohu aplikacniho okna platna.
*/
public Pozice getPozice()
{
return new Pozice(okno.getX(), okno.getY());
}
/***************************************************************************
* Nastavi pozici aplikacniho okna aktivniho platna na obrazovce.
*
* @param x Vodorovna souradnice aplikacniho okna platna.
* @param y Svisla souradnice aplikacniho okna platna.
*/
public synchronized void setPozice(int x, int y)
{
okno.setLocation(x, y);
pozicePlatna = new Point(x, y);
}
/***************************************************************************
* Nastavi pozici aplikacniho okna aktivniho platna na obrazovce.
*
* @param pozice Pozadovana pozice aplikacniho okna platna na obrazovce.
*/
public void setPozice(Pozice pozice)
{
okno.setLocation(pozice.getX(), pozice.getY());
}
// /***************************************************************************
// * Vrati instanci tridy <code>Obrazek</code> zobrazujici zadany vyrez
// * AktivnihoPlatna.
// * @param x Vodorovna pozice pozadovaneho vyrezu
// * @param y Svisla pozice pozadovaneho vyrezu
// * @param sirka Sirka pozadovaneho vyrezu v bodech
// * @param vyska Vyska pozadovaneho vyrezu v bodech
// * @return Instance tridy <code>Obrazek</code> zobrazujici zadany vyrez
// */
// public Obrazek getObrazek(int x, int y, int sirka, int vyska)
// {
// BufferedImage bim = getBufferedImage(x, y, sirka, vyska);
// return new Obrazek(0, 0, bim);
// }
//== OSTATNI NESOUKROME METODY INSTANCI ========================================
/***************************************************************************
* Prevede instanci na retezec. Pouziva se predevsim pri ladeni.
*
* @return Retezcova reprezentace dane instance.
*/
@Override
public String toString()
{
return getClass().getName() + "(krok=" + krok +
", sirka=" + sloupcu + ", vyska=" + radku +
", pozadi=" + barvaPozadi + ")";
}
/***************************************************************************
* Vykresli vsechny elementy.
*/
public void prekresli()
{
if (kreslim) { //Prave prekresluji - volam neprimo sam sebe
return;
}
if ((nekreslit == 0) && isViditelne()) //Mam kreslit a je proc
{
////%A+ =999%
// msgS("prekresli");
////%A-
kreslim = true;
synchronized(platno) {
kreslitko.vyplnRam(0, 0, sirkaBodu, vyskaBodu,
barvaPozadi);
if (mrizka && (barvaCar != barvaPozadi))
{
//Budeme kreslit mrizku -- bude pod obrazci
for (int i=0; i < sloupcu; ) {
svisla[i++].nakresli(kreslitko);
}
for (int i=0; i < radku; ) {
vodorovna[i++].nakresli(kreslitko);
}
}
for (IKresleny predmet : predmety) {
predmet.nakresli(kreslitko);
}
}
//Calls to repaint() don\u2019t need to be done
//from the event-dispatch thread
platno.repaint();
kreslim = false; //Uz nekreslim
////%A+ =999%
// msgF("prekresli");
////%A-
}
}
/***************************************************************************
* Potlaci prekreslovani platna, presneji zvysi hladinu potlaceni
* prekreslovani o jednicku. Navratu do stavu pred volanim teto metody
* se dosahne zavolanim metody <code>vratKresli()</code>.</p>
* <p>
* Metody <code>nekresli()</code> a <code>vratKresli()</code>
* se tak chovaji obdobne jako zavorky, mezi nimiz je vykreslovani
* potlaceno.</p>
*/
public synchronized void nekresli()
{
nekreslit++;
}
/***************************************************************************
* Vrati prekreslovani do stavu pred poslednim volanim metody
* <code>nekresli()</code>. Predchazelo-li proto vice volani metody
* <code>nekresli()</code>, zacne se prekreslovat az po odpovidajim poctu
* zavolani metody <code>vratKresli()</code>.
*
* @throws IllegalStateException
* Je-li metoda volana aniz by predchazelo odpovidajici volani
* <code>nekresli()</code>.
*/
public synchronized void vratKresli()
{
if (nekreslit == 0) {
throw new IllegalStateException(
"Vraceni do stavu kresleni musi prechazet zakaz!");
}
nekreslit--;
if (nekreslit == 0) {
prekresli();
}
}
/***************************************************************************
* Odstrani zadany obrazec ze seznamu malovanych.
* Byl-li obrazec v seznamu, prekresli platno.
*
* @param obrazec Odstranovany obrazec
*
* @return true v pripade, kdyz obrazec v seznamu byl,
* false v pripade, kdyz nebylo co odstranovat
*/
public synchronized boolean odstran(IKresleny obrazec)
{
boolean ret = predmety.remove(obrazec);
if (ret) {
prekresli();
}
return ret;
}
/***************************************************************************
* Vycisti platno, tj. vyprazdni seznam malovanych
* (odstrani z nej vsechny obrazce).
*/
public void odstranVse()
{
nekresli(); {
ListIterator<IKresleny> it = predmety.listIterator();
while (it.hasNext()) {
it.next();
it.remove();
}
} vratKresli();
}
/***************************************************************************
* Neni-li zadany obrazec v seznamu malovanych, prida jej na konec
* (bude se kreslit jako posledni, tj. na vrchu.
* Byl-li obrazec opravdu pridan, prekresli platno.
* Objekty budou vzdy kresleny v poradi, v nemz byly pridany do spravy,
* tj. v seznamu parametru zleva doprava
* a drive zaregistrovane objekty pred objekty zaregistrovanymi pozdeji.
*
* @param obrazec Pridavane obrazce
* @return Pocet skutecne pridanych obrazcu
*/
public synchronized int pridej(IKresleny... obrazec)
{
int pocet = 0;
nekresli(); {
for (IKresleny ik : obrazec)
{
if (! predmety.contains(ik)) {
predmety.add(ik);
pocet++;
}
}
} vratKresli();
return pocet;
}
/***************************************************************************
* Prida obrazec do seznamu malovanych tak, aby byl kreslen
* nad zadanym obrazcem.
* Pokud jiz v seznamu byl, jenom jej presune do zadane pozice.
*
* @param soucasny Obrazec, ktery ma byt pri kresleni pod
* pridavanym obrazcem
* @param pridany Pridavany obrazec
*
* @return {@code true} v pripade, kdyz byl obrazec opravdu pridan,
* {@code false} v pripade, kdyz jiz mezi zobrazovanymi byl
* a pouze se presunul do jine urovne
*/
public synchronized boolean pridejNad(IKresleny soucasny,
IKresleny pridany)
{
boolean nebyl = ! predmety.remove(pridany);
int kam = predmety.indexOf(soucasny);
if (kam < 0)
{
throw new IllegalArgumentException(
"Referencni objekt neni na platne zobrazovan!");
}
predmety.add(kam+1, pridany);
prekresli();
return nebyl;
}
/***************************************************************************
* Prida obrazec do seznamu malovanych tak, aby byl kreslen
* pod zadanym obrazcem.
* Pokud jiz v seznamu byl, jenom jej presune do zadane pozice.
*
* @param soucasny Obrazec, ktery ma byt pri kresleni nad
* pridavanym obrazcem
* @param pridany Pridavany obrazec
*
* @return true v pripade, kdyz byl obrazec opravdu pridan,
* false v pripade, kdyz jiz mezi zobrazovanymi byl
* a pouze se presunul do jine urovne
*/
public synchronized boolean pridejPod(IKresleny soucasny,
IKresleny pridany)
{
boolean nebyl = ! predmety.remove(pridany);
int kam = predmety.indexOf(soucasny);
if (kam < 0)
{
throw new IllegalArgumentException(
"Referencni objekt neni na platne zobrazovan!");
}
predmety.add(kam, pridany);
prekresli();
return nebyl;
}
/***************************************************************************
* Prida obrazec do seznamu malovanych tak, aby byl kreslen
* nad vsemi obrazci.
* Pokud jiz v seznamu byl, jenom jej presune do pozadovane pozice.
*
* @param pridany Pridavany obrazec
*
* @return true v pripade, kdyz byl obrazec opravdu pridan,
* false v pripade, kdyz jiz mezi zobrazovanymi byl
* a pouze se presunul do jine urovne
*/
public
synchronized boolean pridejNavrch(IKresleny pridany)
{
boolean nebyl = ! predmety.remove(pridany);
predmety.add(pridany);
prekresli();
return nebyl;
}
/***************************************************************************
* Prida obrazec do seznamu malovanych tak, aby byl kreslen
* pod zadanym obrazcem.
* Pokud jiz v seznamu byl, jenom jej presune do zadane pozice.
*
* @param pridany Pridavany obrazec
*
* @return true v pripade, kdyz byl obrazec opravdu pridan,
* false v pripade, kdyz jiz mezi zobrazovanymi byl
* a pouze se presunul do jine urovne
*/
public
synchronized boolean pridejDospod(IKresleny pridany)
{
boolean nebyl = ! predmety.remove(pridany);
predmety.add(0, pridany);
prekresli();
return nebyl;
}
/***************************************************************************
* Vrati poradi zadaneho prvku v seznamu kreslenych prvku.
* Prvky se pritom kresli v rostoucim poradi, takze obrazec
* s vetsim poradim je kreslen nad obrazcem s mensim poradim.
* Neni-li zadany obrazec mezi kreslenymi, vrati -1.
*
* @param obrazec Objekt, na jehoz kreslici poradi se dotazujeme
*
* @return Poradi obrazce; prvy kresleny obrazec ma poradi 0.
* Neni-li zadany obrazec mezi kreslenymi, vrati -1.
*/
public
int poradi(IKresleny obrazec)
{
return predmety.indexOf(obrazec);
}
/***************************************************************************
* Vrati nemodifikovatelny seznam vsech spravovanych obrazku.
*
* @return Pozadovany seznam
*/
public
List<IKresleny> seznamKreslenych()
{
return Collections.unmodifiableList(predmety);
}
/***************************************************************************
* Nastavi, zda se maji prihlasenym posluchacum hlasit zmeny
* velikosti kroku a vrati puvodni nastaveni.
*
* @param hlasit Pozadovane nastaveni (true=hlasit, false=nehlasit).
* @return Puvodni nastaveni
*/
public boolean hlasitZmenyRozmeru(boolean hlasit)
{
boolean ret = hlasitZmenyRozmeru;
hlasitZmenyRozmeru = hlasit;
return ret;
}
/***************************************************************************
* Prihlasi posluchace udalosti klavesnice.
*
* @param posluchac Prihlasovany posluchac
*/
public
void prihlasKlavesnici(KeyListener posluchac)
{
okno.addKeyListener(posluchac);
}
/***************************************************************************
* Odhlasi posluchace klavesnice.
*
* @param posluchac Odhlasovany posluchac
*/
public
void odhlasKlavesnici(KeyListener posluchac)
{
okno.removeKeyListener(posluchac);
}
/***************************************************************************
* Prihlasi posluchace udalosti mysi.
*
* @param posluchac Prihlasovany posluchac
*/
public
void prihlasMys(MouseListener posluchac)
{
okno.addMouseListener(posluchac);
}
/***************************************************************************
* Odhlasi posluchace mysi.
*
* @param posluchac Odhlasovany posluchac
*/
public
void odhlasMys(MouseListener posluchac)
{
okno.removeMouseListener(posluchac);
}
// /***************************************************************************
// * Ulozi obraz aktivniho platna do zadaneho souboru.
// *
// * @param soubor Soubor, do nejz se ma obraz platna ulozit
// */
// public
// void ulozJakoObrazek(File soubor)
// {
// BufferedImage bim = getBufferedImage();
// try {
// ImageIO.write(bim, "PNG", soubor);
// } catch(IOException exc) {
// throw new RuntimeException(
// "\nObraz aktivniho platna se nepodarilo ulozit do souboru " +
// soubor, exc);
// }
// }
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
/***************************************************************************
* Bezi-li ve vlakne udalosti, vykona zadanou akci,
* v opacnem pripade ji zaradi do vlakna a pocka na jeji dokonceni.
*
* @param akce Spustena akce
* @param nazev Nazev akce pro kontrolni tisky
*/
private static void invokeAndWait(Runnable akce, String nazev)
{
if (EventQueue.isDispatchThread()) {
akce.run();
return;
}
try {
String zprava = "fronta udalosti - " + nazev;
msgS(zprava);
EventQueue.invokeAndWait(akce);
msgF(zprava);
}
catch (Exception ex) {
throw new RuntimeException( "\nSpusteni akce <<" + nazev +
">> ve fronte udalosti se nezdarilo", ex);
}
}
/***************************************************************************
* Precte parametry z konfiguracniho souboru.
* Tento soubor je umisten v domovskem adresari uzivatele
* ve slozce {@code .rup} v souboru {@code bluej.properties}.
*
* @return Pozice, na kterou se ma umistit aplikacni okno
*/
private static Point konfiguraceZeSouboru()
{
Point pozice;
Properties sysProp = System.getProperties();
String userDir = sysProp.getProperty("user.home");
File rupFile = new File(userDir, ".rup/bluej.properties");
Properties rupProp = new Properties();
try {
Reader reader = new FileReader(rupFile);
rupProp.load(reader);
reader.close();
String sx = rupProp.getProperty("canvas.x");
String sy = rupProp.getProperty("canvas.y");
int x = Integer.parseInt(rupProp.getProperty("canvas.x"));
int y = Integer.parseInt(rupProp.getProperty("canvas.y"));
pozice = new Point(x, y);
}catch(Exception e) {
pozice = new Point(0, 0);
}
return pozice;
}
/***************************************************************************
* Initialize a canvas manager by putting the initializing code
* into the AWT Event Queue.
*/
private static void inicializuj()
{
////%A+ =999%
// msgS("inicializuj()");
////%A-
final Point pozice = konfiguraceZeSouboru();
final Kutloch kutloch = new Kutloch();
Runnable pripravSP = new Runnable() {
@Override public void run()
{
////%A+ =999%
// msgS("run() z inicializuj()");
////%A-
pripravSP(pozice, kutloch);
////%A+ =999%
// msgF("run() z inicializuj()");
////%A-
}
};
try {
EventQueue.invokeAndWait(pripravSP);
} catch (Exception ex) {
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
sw.write("\nCreation of CanvasManager doesn't succeed\n");
ex.printStackTrace(pw);
String msg = sw.toString();
System.err.println(msg);
JOptionPane.showMessageDialog(null, msg);
System.exit(1);
}
//Spravce je vytvoren, budeme umistovat dialogove okna
SpravcePlatna spravce = kutloch.spravce;
int x = spravce.okno.getX();
int y = spravce.okno.getY() + spravce.okno.getHeight();
IO.oknaNa(x, y);
//Vse je hotovo, muzeme atribut inicializovat
SP = spravce;
//Cary se mohou vytvorit az po inicializaci spravce,
//protoze si o nej trida car rekne
SP.pripravCary();
////%A+ =999%
// msgF("inicializuj(): " + SP);
////%A-
}
/***************************************************************************
* Prepares a canvas manager and its application window
* while running in AWT Event Queue.
*
* @param pozice Position of the created application window
* @param kutloch Prepravka pro umisteni vraceneho odkazu na spravce
*/
private static void pripravSP(Point pozice, Kutloch kutloch)
{
////%A+ =999%
// msgS("pripravSP(" + pozice + ")");
////%A-
SpravcePlatna spravce = new SpravcePlatna();
spravce.setNazev(TITULEK_0);
spravce.setPozice(pozice.x, pozice.y);
spravce.setKrokRozmerInterni(KROK_0, SIRKA_0, VYSKA_0);
kutloch.spravce = spravce;
////%A+ =999%
// msgF("pripravSP()");
////%A-
}
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
// /***************************************************************************
// * Vrati obrazek na aktivnim platne.
// *
// * @return Obsah platna jako obrazek
// */
// private BufferedImage getBufferedImage()
// {
// if (obrazPlatna instanceof BufferedImage) {
// return (BufferedImage) obrazPlatna; //==========>
// }
// else {
// return getBufferedImage(0, 0, sirkaBodu, vyskaBodu);
// }
// }
// /***************************************************************************
// * Vrati obrazek vyrezu na aktivnim platne.
// *
// * @param x
// * @param y
// * @param sirka
// * @param vyska
// * @return Vyrez obsahu platna jako obrazek
// */
// private BufferedImage getBufferedImage(int x, int y, int sirka, int vyska)
// {
// BufferedImage ret = new BufferedImage(sirka, vyska,
// BufferedImage.TYPE_INT_ARGB);
// Graphics2D g2d = (Graphics2D)ret.getGraphics();
// g2d.drawImage(obrazPlatna, -x, -y, Kreslitko.OBRAZOR);
// return ret;
// }
/***************************************************************************
* Obvola vsechny spravovane prizpusobive objekty
* a oznami jim zmenu kroku.
*
* @param staryKrok Puvodni velikost kroku
* (aby si ji prizpusobivi nemuseli pamatovat)
* @param novyKrok Nova velikost kroku
*/
private void obvolejPrizpusobive(int staryKrok, int novyKrok)
{
if (hlasitZmenyRozmeru && (staryKrok != novyKrok)) {
nekreslit++; {
for (IKresleny ik : seznamKreslenych()) {
if (ik instanceof IPrizpusobivy) {
((IPrizpusobivy)ik).krokZmenen(staryKrok, novyKrok);
}
}
}nekreslit--;
}
}
/***************************************************************************
* Pripravi cary vyznacujici jednotliva pole aktivniho platna.
* Pokud se cary kreslit nemaji, vyprazdni odkazy na ne.
*/
private void pripravCary()
{
if (mrizka && (krok > 1))
{
if ((svisla == null) || (svisla.length != sloupcu)) {
svisla = new Cara[sloupcu];
}
if ((vodorovna == null) ||
(vodorovna.length != radku))
{
vodorovna = new Cara[radku];
}
for (int i=0, x=krok; i < sloupcu; i++, x+=krok) {
svisla[i] = new Cara(x, 0, x, vyskaBodu, barvaCar);
}
for (int i=0, y=krok; i < radku; i++, y+=krok) {
vodorovna[i] = new Cara(0, y, sirkaBodu, y, barvaCar);
}
}
else
{
//Uvolneni doposud pouzivanych instanci
svisla = null;
vodorovna = null;
mrizka = false;
}
}
/***************************************************************************
*
* @param krok
* @param pSirka
* @param pVyska
* @param menic
* @throws IllegalArgumentException
* @throws IllegalStateException
* @throws HeadlessException
*/
private void setKrokRozmer_OverParametry(int krok,
int pSirka, int pVyska,
Object menic)
throws IllegalArgumentException,
IllegalStateException,
HeadlessException
{
//Kontrola, jestli rozmery meni ten, kdo je menit smi
if ((menic != null) &&
(menic != vlastnikPovoleniZmenyKroku))
{
if (vlastnikPovoleniZmenyKroku == null) {
vlastnikPovoleniZmenyKroku = menic;
} else {
throw new IllegalStateException(
"Zmena kroku a rozmeru neni danemu objektu povolena");
}
}
//Overeni korektnosti zadanych parametru
Dimension obrazovka = Toolkit.getDefaultToolkit().getScreenSize();
if ((krok < 1) ||
(pSirka < 2) || (obrazovka.width < sirkaBodu) ||
(pVyska < 2) || (obrazovka.height < vyskaBodu))
{
throw new IllegalArgumentException(
"\nSpatne zadane rozmery: " +
"\n krok =" + krok + " bodu," +
"\n sirka=" + pSirka +
" poli = " + pSirka*krok + " bodu," +
"\n vyska=" + pVyska +
" poli = " + pVyska*krok + " bodu," +
"\n obrazovka= " + obrazovka.width + "\u00d7" +
obrazovka.height + " bodu\n");
}
}
/***************************************************************************
*
* @param pSirka
* @param krok
* @param pVyska
*/
private void setKrokRozmerInterni(int krok, int pSirka, int pVyska)
{
////%A+ =999%
// msgS("setKrokRozmerInterni: krok=" + krok + ", pSirka=" + pSirka +
// ", pVyska=" + pVyska);
////%A-
sirkaBodu = pSirka * krok;
vyskaBodu = pVyska * krok;
okno.setResizable(true);
platno.setPreferredSize(new Dimension(sirkaBodu, vyskaBodu));
okno.pack();
okno.setResizable(false);
obrazPlatna = platno.createImage(sirkaBodu, vyskaBodu);
kreslitko = new Kreslitko((Graphics2D)obrazPlatna.getGraphics());
kreslitko.setPozadi(barvaPozadi);
this.krok = krok;
this.sloupcu = pSirka;
this.radku = pVyska;
// IO.Oprava.rozmerOkna(okno);
// IO.Oprava.poziceOkna(okno);
////%A+ =999%
// msgF("setKrokRozmerInterni");
////%A-
}
/***************************************************************************
*
* @param viditelne
*/
private void setViditelneInterni(final boolean viditelne)
{
////%A+ =999%
// msgS("setViditelneInterni");
////%A-
okno.setVisible(viditelne);
if (viditelne)
{
//Na WinXP pri vice obrazovkach po zviditelneni blblo
//=> bylo treba znovu nastavit pozici
okno.setLocation(pozicePlatna);
okno.setAlwaysOnTop(true);
okno.toFront();
prekresli();
okno.pack();
okno.setAlwaysOnTop(false);
}
////%A+ =999%
// msgF("setViditelneInterni");
////%A-
}
/***************************************************************************
*
*/
private void setViditelne_Pockam()
{
////%A+ =999%
// msgS("setViditelne_Pockam");
////%A-
if (EventQueue.isDispatchThread()) {
okno.setVisible(true);
okno.pack();
////%A+ =999%
// msgF("setViditelne_Pockam - from DispatchThread");
////%A-
return;
}
Runnable runnable = new Runnable()
{
@Override
public void run()
{
////%A+ =999%
// msgS("run() from setViditelne_Pockam");
////%A-
okno.setVisible(true);
prekresli();
okno.pack();
////%A+ =999%
// msgF("run() from setViditelne_Pockam");
////%A-
}
};
try {
EventQueue.invokeAndWait(runnable);
}
catch (InterruptedException ex) {
Thread.currentThread().interrupt();
return;
}
catch (InvocationTargetException ex) {
throw new RuntimeException(
"\nVyjimka vyhozena behem nastavovani kroku a rozmeru", ex );
}
////%A+ =999%
// msgF("setViditelne_Pockam");
////%A-
}
//== VNORENE A VNITRNI TRIDY ===================================================
/***************************************************************************
* Prepravka, v niz uzaver predava vytvoreneho spravce.
*/
private static class Kutloch
{
volatile SpravcePlatna spravce;
}
//== TESTY A METODA MAIN =======================================================
private static void msgS(String text) {
// rup.cesky.utility.ThreadMessages.msgS(text);
}
private static void msg(String text) {
// rup.cesky.utility.ThreadMessages.msg(text);
}
private static void msgF(String text) {
// rup.cesky.utility.ThreadMessages.msgF(text);
}
/***************************************************************************
*
*/
private static void w() {
try{
Thread.sleep(10);
}
catch(InterruptedException e){}
}
// /***************************************************************************
// * Testovaci metoda
// */
// public static void test2()
// {
// //Abych zarucil inicializovanost SP
// SpravcePlatna sp = SpravcePlatna.getInstance();
// sp.pridej(new Obdelnik()); w();
// sp.pridej(new Elipsa(), new Trojuhelnik()); w();
// IO.zprava("Vychozi obrazek - budu vyjimat vyrez");
// Obrazek obr = SP.getObrazek(50, 0, 75, 75); w();
// sp.pridej(obr); w();
// sp.setBarvaPozadi(Barva.CERNA); w();
// IO.zprava("Obrazek pridany?");
// obr.setPozice(100, 50); w();
// IO.zprava("Posunuty?");
// obr.setRozmer(150, 150); w();
// IO.zprava("Zvetseny?");
// sp.setKrokRozmer(50, 5, 2);
//// SP.setKrokRozmer(1, 50, 50);
//// SP.ulozJakoObrazek(new File("D:/SMAZAT.PNG"));
// System.exit(0);
// }
/***************************************************************************
* Testovaci metoda
*/
public static void test()
{
////%A+ =999%
// msgS("test");
////%A-
getInstance(); //Abych zarucil nastavenost SP
////%A+ =999%
// msg("test - SP vytvoren");
////%A-
IO.zprava("Platno vytvoreno");
////%A+ =999%
// msg("test - Prvni IO zavreno");
////%A-
SP.pridej(new Obdelnik (0, 0, 300, 300));
SP.pridej(new Elipsa (0, 0, 300, 300));
SP.pridej(new Trojuhelnik(0, 0, 300, 300));
////%A+ =999%
// msg("test - triumvirat vytvoren");
////%A-
IO.zprava("Triumvirat nakreslen");
////%A+ =999%
// msg("test - Druhe IO zavreno");
////%A-
SP.pridej(new Obdelnik ( 99, 99, 102, 102),
new Elipsa (100, 100, 100, 100),
new Trojuhelnik(100, 100, 100, 100));
////%A+ =999%
// msg("test - druhy triumvirat vytvoren");
////%A-
IO.zprava("Druhy triumvirat nakreslen");
////%A+ =999%
// msg("test - Treti IO zavreno");
////%A-
////%A+ =999%
// msgF("test");
////%A-
System.exit(0);
}
/** @param args Paremtry prikazoveho radku - nepouzite */
public static void main(String[] args) { test(); } /**/
////%A+ =999%
// {
// msgF("SpravcePlatna - deklarace atributu instance");
// }
// static {
// msgF("SpravcePlatna - class constructor");
// }
////%A-
}
Raw
Displej_projekt_src_knihovna_Terc.java
package knihovna;
public class Terc extends Kruh{
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
private static final Barva ZLUTA = Barva.ZLUTA;
private static final Barva MODRA = Barva.MODRA;
private static final Barva CERVENA = Barva.CERVENA;
private static int poradi;
private final Kruh kruhU;
private final Kruh kruhS;
private final Cara caraV;
private final Cara caraS;
private int krok;
private int vel2;
private int vel3;
private int vel6;
public Terc(){
this(SP.getKrok()/2, SP.getKrok()/2);
}
public Terc(int x, int y){
this(x, y, SP.getKrok());
}
public Terc(int x, int y, int velikost){
this(x, y, velikost, ZLUTA, MODRA, CERVENA);
}
public Terc(int x, int y, int velikost, Barva barva1, Barva barva2, Barva barva3){
super();
this.krok = SP.getKrok();
this.vel2 = velikost/2;
this.vel3 = velikost/3;
this.vel6 = velikost/6;
kruhU = new Kruh();
kruhS = new Kruh();
caraV = new Cara();
caraS = new Cara();
setPozice(x, y);
setRozmer(velikost);
super.setBarva(barva1);
kruhU.setBarva(barva2);
kruhS.setBarva(barva3);
Terc.poradi++;
}
/***************************************************************************
* Nastavi novou pozici instance.
*
* @param x Nova x-ova pozice instance
* @param y Nova y-ova pozice instance
*/
@Override
public void setPozice(int x, int y)
{
SP.nekresli(); {
super.setPozice(x-vel2, y-vel2);
kruhU.setPozice(x-vel3, y-vel3);
kruhS.setPozice(x-vel6, y-vel6);
caraV.setPozice(x-vel2, y);
caraS.setPozice(x, y-vel2);
} SP.vratKresli();
}
@Override
public int getX(){
Pozice p = getPozice();
return p.x;
}
@Override
public int getY(){
Pozice p = getPozice();
return p.y;
}
@Override
public Oblast getOblast(){
Pozice p = getPozice();
Rozmer r = super.getRozmer();
return new Oblast(p, r);
}
@Override
public Pozice getPozice(){
int x = caraV.getX();
int y = caraS.getY();
return new Pozice(x + vel2, y + vel2);
}
// @Override
// public void setRozmer(int sirka, int vyska){
// int i = Math.min(sirka, vyska);
// this.setRozmer(i);
// }
/***************************************************************************
* Nastavi novou velikost nafukovaciho objektu;
* pozice objektu by se pritom nemela zmenit.
*
* @param vyska Nova sirka objektu
* @param sirka Nova vyska objektu
*/
@Override
public void setRozmer(int velikost){
setRozmer(velikost, velikost);
}
/***************************************************************************
* Nastavi novou velikost nafukovaciho objektu;
* pozice objektu by se pritom nemela zmenit.
*
* @param vyska Nova sirka objektu
* @param sirka Nova vyska objektu
*/
@Override
public void setRozmer(int sir, int vys){
Pozice p = getPozice();
this.vel2 = (sir+vys)/4;
this.vel3 = (sir+vys)/2/3;
this.vel6 = (sir+vys)/2/6;
int x = super.getX();
int y = super.getY();
SP.nekresli(); {
super.setRozmer((sir+vys)/2, (sir+vys)/2);
kruhU.setRozmer(vel3*2, vel3*2);
kruhS.setRozmer(vel3, vel3);
caraV.setPozice(x - vel2, y);
caraV.setKPozice(x + vel2, y);
caraS.setPozice(x, y - vel2);
caraS.setKPozice(x, y + vel2);
setPozice(p);
} SP.vratKresli();
}
public void setOblast(Oblast o){
setPozice(o.x, o.y);
setRozmer(o.sirka, o.vyska);
}
/***************************************************************************
* Presune instanci o zadany pocet bodu vpravo,
* pri zaporne hodnote parametru vlevo.
*
* @param vzdalenost Vzdalenost, o kterou se instance presune.
*/
public void posunVpravo(int vzdalenost)
{
setPozice(getX() + vzdalenost, getY() );
}
/***************************************************************************
* Presune instanci o zadany pocet bodu dolu,
* pri zaporne hodnote parametru nahoru.
*
* @param vzdalenost Pocet bodu, o ktere se instance presune.
*/
public void posunDolu(int vzdalenost)
{
setPozice( getX(), getY() + vzdalenost );
}
/***************************************************************************
* Presune instanci o krok bodu vpravo.
*/
public void posunVpravo()
{
posunVpravo( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu vlevo.
*/
public void posunVlevo()
{
posunVpravo( -SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu dolu.
*/
public void posunDolu()
{
posunDolu( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu nahoru.
*/
public void posunVzhuru()
{
posunDolu( -SP.getKrok() );
}
// nakresli xobdelnik
@Override
public void nakresli(Kreslitko k)
{
super.nakresli(k);
kruhU.nakresli(k);
kruhS.nakresli(k);
caraV.nakresli(k);
caraS.nakresli(k);
}
@Override
public String toString(){
Oblast o = this.getOblast();
return "terc_"+ poradi + ": x=" + o.x + ", y=" + o.y +
", sirka=" + o.sirka + ", vyska=" + o.vyska +
", barva=" + super.getBarva();
}
}
Raw
Displej_projekt_src_knihovna_Text.java
package knihovna;
import java.awt.*;
/*******************************************************************************
* Trida pro Zobrazeni textu na aktivnim platne.
*
* Oproti verzi z balicku <b>rup.cesky._10_dedicnost_trid.tvary_1</b>
* se nic nezmenilo
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Text extends APosuvny
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Konstanta oznacujici text vysazeny netucnym, nekurzivnim pismem. */
public static final int OBYCEJNY = Font.PLAIN;
/** Konstanta oznacujici text vysazeny tucnym, nekurzivnim pismem. */
public static final int TUCNY = Font.BOLD;
/** Konstanta oznacujici text vysazeny netucnym, kurzivnim pismem. */
public static final int KURZIVA = Font.ITALIC;
/** Pocatecni barva nakreslene instance v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada -
* pro text Barva.CERNA. */
public static final Barva IMPLICITNI_BARVA = Barva.CERNA;
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private String text; //Zobrazovany text
private Barva barva; //Barva instance
private Font font; //Pismo, kterym se text sazi
private Font kfont; //Pismo nastavene pro kreslitko
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI NESOUKROME METODY TRIDY ===========================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* a vysazena implicitnim pismem (tucnym 12bodovym pismem Dialog).
*
* @param text Vypisovany text
*/
public Text( String text )
{
this( text, 0, 0 );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou
* a vysazena implicitnim pismem (tucnym 12bodovym pismem Dialog).
*
* @param text Vypisovany text
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
*/
public Text( String text, int x, int y )
{
this( text, x, y, IMPLICITNI_BARVA );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou
* a implicitnim pismem (bude vysazen tucnym 12bodovym pismem Dialog).
*
* @param text Vypisovany text
* @param pocatek Pozice pocatku instance
*/
public Text( String text, Pozice pocatek )
{
this( text, pocatek.x, pocatek.y );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery a barvou.
*
* @param text Vypisovany text
* @param pocatek Pozice pocatku instance
* @param barva Barva vytvarene instance
*/
public Text(String text, Pozice pocatek, Barva barva)
{
this( text, pocatek.x, pocatek.y, barva );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery a barvou.
*
* @param text Vypisovany text
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param barva Barva vytvarene instance
*/
public Text( String text, int x, int y, Barva barva )
{
super( x, y );
this.text = text;
this.barva = barva;
this.font = new Font( "Dialog", Font.BOLD, 12 );
setNazev(text);
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Vrati barvu instance.
*
* @return Instance tridy Barva definujici nastavenou barvu.
*/
public Barva getBarva()
{
return barva;
}
/***************************************************************************
* Nastavi novou barvu instance.
*
* @param nova Pozadovana nova barva.
*/
public void setBarva(Barva nova)
{
barva = nova;
SP.prekresli();
}
/***************************************************************************
* Vrati vypisovany text.
*
* @return Vypisovany text
*/
public String getText() {
return text;
}
/***************************************************************************
* Nastavi vypisovany text.
*
* @param text Vypisovany text
*/
public void setText(String text) {
this.text = text;
SP.prekresli();
}
/***************************************************************************
* Nastavi font, kterym se bude dany text sazet.
*
* @param nazev Nazev fontu - je mozno zadat jeden z nazvu:
* "Dialog", "DialogInput", "Monospaced",
* "Serif", "SansSerif".
* @param rez Je mozno zadat nektery z rezu:
* Text.OBYCEJNY, Text.TUCNY, Text.KURZIVA,
* pripadne Text.TUCNY|Text.KURZIVA
* @param velikost Velikost pisma v bodech.
*/
public void setFont( String nazev, int rez, int velikost )
{
font = new Font( nazev, rez, velikost );
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli( Kreslitko kreslitko )
{
if( font != kfont )
{
kreslitko.setFont( font );
kfont = font;
}
kreslitko.kresliText( getNazev(), getX(), getY() + font.getSize(),
getBarva() );
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Prevede instanci na retezec. Pouziva se predevsim pri ladeni.
*
* @return Retezcova reprezentace dane instance.
*/
@Override
public String toString()
{
return text;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_Trojuhelnik.java
package knihovna;
/*******************************************************************************
* Trida pro praci s trojuhelnikem komunikujicim s aktivnim platnem.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class Trojuhelnik extends AHybaci
{
//== KONSTANTNI ATRIBUTY TRIDY =================================================
/** Pocatecni barva nakreslene instance v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada -
* pro trojuhelnik Barva.ZELENA. */
public static final Barva IMPLICITNI_BARVA = Barva.ZELENA;
/** Pocatecni barva nakresleneho trojuhelniku v pripade,
* kdy uzivatel zadnou pozadovanou barvu nezada. */
public static final Smer8 IMPLICITNI_SMER = Smer8.SEVER;
//== PROMENNE ATRIBUTY TRIDY ===================================================
//== KONSTANTNI ATRIBUTY INSTANCI ==============================================
//== PROMENNE ATRIBUTY INSTANCI ================================================
private Barva barva; //Barva instance
private Smer8 smer; //Smer, do nejz je otocen vrchol trojuhelniku
//== PRISTUPOVE METODY VLASTNOSTI TRIDY ========================================
//== OSTATNI METODY TRIDY ======================================================
//##############################################################################
//== KONSTRUKTORY A TOVARNI METODY =============================================
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim, barvou
* a natocenim.
* Instance bude umistena v levem hornim rohu platna
* a bude mit implicitni barvu,
* vysku rovnu kroku a sirku dvojnasobku kroku (tj. implicitne 50x100 bodu)
* a bude natocena vrocholem na sever.
*/
public Trojuhelnik()
{
this( 0, 0, 2*SP.getKrok(), SP.getKrok() );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou a smerem natoceni.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka sirka vytvarene instance, sirka >= 0
* @param vyska vyska vytvarene instance, vyska >= 0
*/
public Trojuhelnik( int x, int y, int sirka, int vyska )
{
this( x, y, sirka, vyska, IMPLICITNI_BARVA, IMPLICITNI_SMER );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou, rozmery a smerem natoceni
* a s implicitni barvou.
*
* @param x x-ova souradnice, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice, y>=0, y=0 ma horni okraj platna
* @param sirka sirka instance, sirka >= 0
* @param vyska vyska instance, vyska >= 0
* @param smer Smer, do nejz bude natocen vrchol trojuhelniku -
* je treba zadat nekterou z instanci tridy Smer8
*/
public Trojuhelnik( int x, int y, int sirka, int vyska, Smer8 smer )
{
this( x, y, sirka, vyska, IMPLICITNI_BARVA, smer );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou a barvou.
* Smer natoceni bude implicitni, tj. na sever.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka sirka vytvarene instance, sirka >= 0
* @param vyska vyska vytvarene instance, vyska >= 0
* @param barva Barva vytvarene instance
*/
public Trojuhelnik( int x, int y, int sirka, int vyska, Barva barva )
{
this( x, y, sirka, vyska, barva, IMPLICITNI_SMER );
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery, barvou a merem.
*
* @param pozice Pozice vytvarene instance
* @param rozmer Rozmer vytvarene instance
* @param barva Barva vytvarene instance
* @param smer Smer, do nejz je natocen vrchol trojuhelniku -
* je treba zadat nekterou z instanci tridy Smer8
*/
public Trojuhelnik( Pozice pozice, Rozmer rozmer, Barva barva, Smer8 smer )
{
this( pozice.x, pozice.y, rozmer.sirka, rozmer.vyska, barva, smer );
}
/***************************************************************************
* Vytvori novou instanci v zadane oblasti a se zadanou barvou.
*
* @param oblast Oblast, v niz se ma instance vytvorit
* @param barva Barva vytvarene instance
* @param smer Smer, do nejz je natocen vrchol trojuhelniku -
* je treba zadat nekterou z instanci tridy Smer8
*/
public Trojuhelnik( Oblast oblast, Barva barva, Smer8 smer )
{
this( oblast.x, oblast.y, oblast.sirka, oblast.vyska, barva, smer );
}
/***************************************************************************
* Vytvori novou instanci se zadanymi rozmery, polohou, barvou,
* i smerem natoceni.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka sirka vytvarene instance, sirka >= 0
* @param vyska vyska vytvarene instance, vyska >= 0
* @param barva Barva vytvarene instance
* @param smer Smer, do nejz bude natocen vrchol trojuhelniku -
* je treba zadat nekterou z instanci tridy Smer8
*/
public Trojuhelnik( int x, int y, int sirka, int vyska, Barva barva, Smer8 smer )
{
super( x, y, sirka, vyska );
this.barva = barva;
this.smer = smer;
}
//== PRISTUPOVE METODY ATRIBUTU INSTANCI =======================================
/***************************************************************************
* Vrati barvu instance.
*
* @return Instance tridy Barva definujici nastavenou barvu.
*/
public Barva getBarva()
{
return barva;
}
/***************************************************************************
* Nastavi novou barvu instance.
*
* @param nova Pozadovana nova barva.
*/
public void setBarva(Barva nova)
{
barva = nova;
SP.prekresli();
}
/***************************************************************************
* Vrati smer instance. tj. smer, co nejz je otocen vrchol.
*
* @return Instance tridy Smer8 definujici nastaveny smer.
*/
public Smer8 getSmer()
{
return smer;
}
/***************************************************************************
* Nastavi novy smer instance.
*
* @param novy Pozadovany novy smer.
*/
public void setSmer(Smer8 novy)
{
smer = novy;
SP.prekresli();
}
//== PREKRYTE METODY IMPLEMENTOVANYCH ROZHRANI =================================
/***************************************************************************
* Za pomoci dodaneho kreslitka vykresli obraz sve instance
* na animacni platno.
*
* @param kreslitko Kreslitko, kterym se instance nakresli na platno.
*/
public void nakresli( Kreslitko kreslitko )
{
int[][] points = getVrcholy();
kreslitko.vyplnPolygon( points[0], points[1], barva );
}
//== PREKRYTE ABSTRAKTNI METODY RODICOVSKE TRIDY ===============================
//== PREKRYTE KONKRETNI METODY RODICOVSKE TRIDY ================================
/***************************************************************************
* Prevede instanci na retezec. Pouziva se predevsim pri ladeni.
*
* @return Retezcova reprezentace dane instance.
*/
@Override
public String toString()
{
return super.toString() + ", barva=" + barva + ", smer=" + smer;
}
//== NOVE ZAVEDENE METODY INSTANCI =============================================
//== SOUKROME A POMOCNE METODY TRIDY ===========================================
//== SOUKROME A POMOCNE METODY INSTANCI ========================================
/***************************************************************************
* Vrati matici se souradnicemi vrcholu daneho trojuhelniku.
*
* @return Pozadovana matice
*/
private int[][] getVrcholy()
{
int[] x = null;
int[] y = null;
//Volam rodicovskou verzi metody, abych mel jistotu, co se zavola,
//a aby se pri prekryti nektere z pouzitych metod
//nezavolalo neco jineho, co muze vrati pro mne nevhodnou hodnotu.
int gx = super.getX();
int gy = super.getY();
int gs = super.getSirka();
int gv = super.getVyska();
switch( smer )
{
case VYCHOD:
x = new int[]{ gx, gx+gs, gx };
y = new int[]{ gy, gy+(gv/2), gy+gv };
break;
case SEVEROVYCHOD:
x = new int[]{ gx, gx+gs, gx+gs };
y = new int[]{ gy, gy, gy+gv };
break;
case SEVER:
x = new int[]{ gx, gx+(gs/2), gx+gs };
y = new int[]{ gy+gv, gy, gy+gv };
break;
case SEVEROZAPAD:
x = new int[]{ gx, gx, gx+gs };
y = new int[]{ gy+gv, gy, gy };
break;
case ZAPAD:
x = new int[]{ gx, gx+gs, gx+gs };
y = new int[]{ gy+(gv/2), gy, gy+gv };
break;
case JIHOZAPAD:
x = new int[]{ gx, gx, gx+gs };
y = new int[]{ gy, gy+gv, gy+gv };
break;
case JIH:
x = new int[]{ gx, gx+(gs/2), gx+gs };
y = new int[]{ gy, gy+gv, gy };
break;
case JIHOVYCHOD:
x = new int[]{ gx, gx+gs, gx+gs };
y = new int[]{ gy+gv, gy+gv, gy };
break;
default:
throw new IllegalStateException(
"Instance ukazuje do nedefinovaneho smeru" );
}
return new int[][] { x, y };
}
//== VNORENE A VNITRNI TRIDY ===================================================
//== TESTY A METODA MAIN =======================================================
}
Raw
Displej_projekt_src_knihovna_XObdelnik.java
package knihovna;
/*******************************************************************************
* Trida {@code XObdelnik} je prazdnou verzi tridy vytvorene v 10. kapitole.
*
* @author Rudolf PECINOVSKY
* @version 2.05.2611 \u2014 2011-09-25
*/
public class XObdelnik extends Obdelnik{
private final int krok = Elipsa.SP.getKrok();
private final Cara cara1;
private final Cara cara2;
private int sir2;
private int vys2;
/***************************************************************************
* Vytvori novou instanci s implicitnimi rozmery, umistenim a barvou.
* Instance bude mit stred na pruseciku hran prvniho a druheho pole
* a bude mit vysku 1 pole a sirku 2 pole.
*/
public XObdelnik(){
this(SP.getKrok(), SP.getKrok());
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
*/
public XObdelnik(int x, int y){
this(x, y, SP.getKrok()*2, SP.getKrok());
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery
* a implicitni barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka > 0
* @param vyska Vyska vytvarene instance, vyska > 0
*/
public XObdelnik(int x, int y, int sirka, int vyska){
this(x, y, sirka, vyska, Obdelnik.IMPLICITNI_BARVA);
}
/***************************************************************************
* Vytvori novou instanci se zadanou polohou a rozmery a barvou.
*
* @param x x-ova souradnice instance, x>=0, x=0 ma levy okraj platna
* @param y y-ova souradnice instance, y>=0, y=0 ma horni okraj platna
* @param sirka Sirka vytvarene instance, sirka > 0
* @param vyska Vyska vytvarene instance, vyska > 0
* @param barva Barva obdelnika tvoriciho instanci
*/
public XObdelnik(int x, int y, int sirka, int vyska, Barva barva){
super();
cara1 = new Cara();
cara2 = new Cara();
this.sir2 = getSirka()/2;
this.vys2 = getVyska()/2;
setPozice(x, y);
setRozmer(sirka, vyska);
super.setBarva(barva);
}
/***************************************************************************
* Nastavi novou pozici instance.
*
* @param x Nova x-ova pozice instance
* @param y Nova y-ova pozice instance
*/
@Override
public void setPozice(int x, int y)
{
SP.nekresli(); {
super.setPozice(x-sir2, y-vys2);
cara1.setPozice(x-sir2, y-vys2);
cara2.setPozice(x-sir2, y+vys2);
} SP.vratKresli();
}
@Override
public int getX(){
Pozice p = getPozice();
return p.x;
}
@Override
public int getY(){
Pozice p = getPozice();
return p.y;
}
@Override
public Oblast getOblast(){
Pozice p = getPozice();
Rozmer r = super.getRozmer();
return new Oblast(p, r);
}
@Override
public Pozice getPozice(){
Pozice p = cara1.getPozice();
return new Pozice(p.x + sir2, p.y + vys2);
}
/***************************************************************************
* Nastavi nove rozmery nafukovaciho objektu zadane jako jako instance
* tridy {@code Rozmer}; pozice objektu by se pritom nemela zmenit.
*
* @param rozmer Nove rozmery objektu
*/
@Override
public void setRozmer( Rozmer rozmer ){
setRozmer(rozmer.sirka, rozmer.vyska);
}
/***************************************************************************
* Nastavi novou velikost nafukovaciho objektu;
* pozice objektu by se pritom nemela zmenit.
*
* @param vyska Nova sirka objektu
* @param sirka Nova vyska objektu
*/
@Override
public void setRozmer(int sirka, int vyska){
SP.nekresli(); {
Pozice p = getPozice();
super.setRozmer(sirka, vyska);
this.sir2 = sirka/2;
this.vys2 = vyska/2;
int x = super.getX() + sir2;
int y = super.getY() + vys2;
cara1.setPozice(x-sir2, y-vys2);
cara1.setKPozice(x-sir2+sirka, y-vys2+vyska);
cara2.setPozice(x-sir2, y+vys2);
cara2.setKPozice(x-sir2+sirka, y+vys2-vyska);
setPozice(p);
} SP.vratKresli();
}
/***************************************************************************
* Presune instanci o zadany pocet bodu vpravo,
* pri zaporne hodnote parametru vlevo.
*
* @param vzdalenost Vzdalenost, o kterou se instance presune.
*/
public void posunVpravo(int vzdalenost)
{
setPozice(getX() + vzdalenost, getY() );
}
/***************************************************************************
* Presune instanci o zadany pocet bodu dolu,
* pri zaporne hodnote parametru nahoru.
*
* @param vzdalenost Pocet bodu, o ktere se instance presune.
*/
public void posunDolu(int vzdalenost)
{
setPozice( getX(), getY() + vzdalenost );
}
/***************************************************************************
* Presune instanci o krok bodu vpravo.
*/
public void posunVpravo()
{
posunVpravo( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu vlevo.
*/
public void posunVlevo()
{
posunVpravo( -SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu dolu.
*/
public void posunDolu()
{
posunDolu( SP.getKrok() );
}
/***************************************************************************
* Presune instanci o krok bodu nahoru.
*/
public void posunVzhuru()
{
posunDolu( -SP.getKrok() );
}
// nakresli xobdelnik
@Override
public void nakresli(Kreslitko k)
{
super.nakresli(k);
cara1.nakresli(k);
cara2.nakresli(k);
}
@Override
public String toString(){
Oblast o = this.getOblast();
return super.getNazev() + ": x=" + o.x + ", y=" + o.y +
", sirka=" + o.sirka + ", vyska=" + o.vyska +
", barva=" + super.getBarva();
}
}
Raw
Displej_projekt_src_projekt_BlokSegmentu.java
package projekt;
import knihovna.*;
/**
* Created by cechd on 07.12.2016.
*/
public class BlokSegmentu{
// konstanty
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
private static final int SIRKA_P = SP.getBsirka();
private static final int KROK = SP.getKrok();
private static final int SIRKA_B = 5 * KROK;
private static final int K2 = KROK / 2;
static final int M = 1;
private static final int M2 = M * 2;
private static final int M3 = M * 3;
private static final int M4 = M * 4;
private static final Barva BARVA = Barva.BILA;
private final Segment s1;
private final Segment s2;
private final Segment s3;
private final Segment s4;
private final Segment s5;
private final Segment s6;
private final Segment s7;
private final Segment s8;
Segment[] segmenty = new Segment[8];
/**
* Konstruktor
*/
BlokSegmentu(int poradi){
s1 = new Segment(SIRKA_P - (SIRKA_B * poradi) + M, KROK, false);
s2 = new Segment(SIRKA_P - (SIRKA_B * poradi) + KROK * 3 + M2, KROK + M, true);
s3 = new Segment(SIRKA_P - (SIRKA_B * poradi) + KROK * 3 + M2, KROK + KROK * 3 + M3, true);
s4 = new Segment(SIRKA_P - (SIRKA_B * poradi) + M, KROK + KROK * 6 + M4, false);
s5 = new Segment(SIRKA_P - (SIRKA_B * poradi), KROK + KROK * 3 + M3, true);
s6 = new Segment(SIRKA_P - (SIRKA_B * poradi), KROK + M, true);
s7 = new Segment(SIRKA_P - (SIRKA_B * poradi) + M, KROK + KROK * 3 + M2, false);
s8 = new Segment(SIRKA_P - (SIRKA_B * poradi) + KROK * 4 + M4, KROK * 8 - M4);
segmenty[0] = s1;
segmenty[1] = s2;
segmenty[2] = s3;
segmenty[3] = s4;
segmenty[4] = s5;
segmenty[5] = s6;
segmenty[6] = s7;
segmenty[7] = s8;
}
public void vykresliSegmenty(String ovladac){
int delka = ovladac.length();
if(delka == 8){
int i = 0;
for(Segment s : segmenty){
if(ovladac.charAt(i) == '1'){
s.zobraz();
}else
s.zhasni();
i++;
}
}
}
/**
* Trida Segment.
* Stara se o zobrazeni jedineho segmentu na zadane souradnici
* a v zadane polarite ... vodorovne jako false a svisle jako true (01)
*/
private class Segment implements IKresleny{
private final boolean pol;
private int x;
private int y;
private Obdelnik telo;
private Trojuhelnik t1;
private Trojuhelnik t2;
public Segment(int x, int y, boolean polarizace){
this.x = x;
this.y = y;
int sirka = KROK * 2;
int vyska = KROK;
this.pol = polarizace; // true - svisly, false - vodorovny
if(polarizace == true){ // nastavi polaritu segmentu
sirka = KROK;
vyska = KROK * 2;
telo = new Obdelnik(x, y + KROK, sirka, vyska, BARVA);
t1 = new Trojuhelnik(x, y + K2, KROK, K2, BARVA, Smer8.SEVER);
t2 = new Trojuhelnik(x, y + KROK*3, KROK, K2, BARVA, Smer8.JIH);
}else{
telo = new Obdelnik(x + KROK, y, sirka, vyska, BARVA);
t1 = new Trojuhelnik(x + K2, y, K2, KROK, BARVA, Smer8.ZAPAD);
t2 = new Trojuhelnik(x + KROK*3, y, K2, KROK, BARVA, Smer8.VYCHOD);
}
}
public Segment(int x, int y){
telo = new Obdelnik(x, y, KROK/3*2, KROK/3*2, BARVA);
t1 = new Trojuhelnik(1,1,1,1,Barva.ZADNA);
t2 = new Trojuhelnik(1,1,1,1,Barva.ZADNA);
pol = false;
}
private void zobraz(){
SP.pridej(this);
}
private void zhasni(){
SP.odstran(this);
}
@Override
public void nakresli(Kreslitko k) {
telo.nakresli(k);
t1.nakresli(k);
t2.nakresli(k);
}
}
}
Raw
Displej_projekt_src_projekt_Cislice.java
package projekt;
/**
* Created by cechd on 07.12.2016.
*/
public class Cislice {
private static final String[] cislice = { "11111100" // nula
,"01100000" // jedna
,"11011010" // dva
,"11110010" // tri
,"01100110" // ctyri
,"10110110" // pet
,"10111110" // sest
,"11100000" // sedm
,"11111110" // osm
,"11110110" // devet
};
private int cislo;
private BlokSegmentu segmentovaCislice;
Cislice(int cislo, int pozice){
segmentovaCislice = new BlokSegmentu(pozice);
zobrazCislici(cislo);
}
void zobrazCislici(int i){
segmentovaCislice.vykresliSegmenty(cislice[i]);
this.cislo = i;
}
int getCislo(){
return this.cislo;
}
}
Raw
Displej_projekt_src_projekt_Displej.java
package projekt;
import knihovna.Barva;
import knihovna.IO;
import knihovna.SpravcePlatna;
/**
* Program segmentovy displej simuluje displej s bloky segmentu,
* kterym je posilan binarni kod jez rozsveci nebo zhasina bloky
* a tim zobravuje na displeji cisla.
*
* Created by cechd on 07.12.2016.
*/
public class Displej {
private static final SpravcePlatna SP = SpravcePlatna.getInstance();
/**
*
* @param pocetCislic ... nastavi sirku displeje tak aby se na nej vesel dany pocet cislic
* @param velikost ... nastavi celkovou velikost displeje a cisel
*/
private Displej(int pocetCislic, int velikost){
SP.setKrokRozmer(velikost*10, 5 * pocetCislic + 1, 9);
SP.setBarvaPozadi(Barva.CERNA);
}
private void stopky(){
Cislice cislo = new Cislice(0, 1);
Cislice cislo2 = new Cislice(0, 2);
while(true){
cislo.zobrazCislici(0);
cislo2.zobrazCislici(0);
for(int j = 0; j < 10; j++){
for (int i = 0; i < 10; i++) {
IO.cekej(1000);
cislo.zobrazCislici(i);
cislo2.zobrazCislici(j);
}
}
}
}
private void hodiny(){
}
public static void main(String[] argv) {
Displej d = new Displej(2, 3);
try {
d.stopky();
}catch (IllegalArgumentException e){ System.err.println("Moc cisel na prilis maly displej!");}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment