emmanuel/gclc-core
emmanuel/gclc-core
1
0
Fork 0
Code Issues 2 Pull Requests Projects 1 Releases Wiki Activity

License and refactoring of packages

Browse Source 
Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>
This commit is contained in:
Emmanuel Bigeon 2018-10-08 14:50:49 -04:00
parent a368e21668
commit c433175aa5
10 changed files with 2315 additions and 1529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

517
gclc-swt/LICENSE.txt Normal file
View File

@ -0,0 +1,517 @@
CeCILL FREE SOFTWARE LICENSE AGREEMENT
Version 2.1 dated 2013-06-21
Notice
This Agreement is a Free Software license agreement that is the result
of discussions between its authors in order to ensure compliance with
the two main principles guiding its drafting:
* firstly, compliance with the principles governing the distribution
of Free Software: access to source code, broad rights granted to users,
* secondly, the election of a governing law, French law, with which it
is conformant, both as regards the law of torts and intellectual
property law, and the protection that it offers to both authors and
holders of the economic rights over software.
The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre])
license are:
Commissariat à l'énergie atomique et aux énergies alternatives - CEA, a
public scientific, technical and industrial research establishment,
having its principal place of business at 25 rue Leblanc, immeuble Le
Ponant D, 75015 Paris, France.
Centre National de la Recherche Scientifique - CNRS, a public scientific
and technological establishment, having its principal place of business
at 3 rue Michel-Ange, 75794 Paris cedex 16, France.
Institut National de Recherche en Informatique et en Automatique -
Inria, a public scientific and technological establishment, having its
principal place of business at Domaine de Voluceau, Rocquencourt, BP
105, 78153 Le Chesnay cedex, France.
Preamble
The purpose of this Free Software license agreement is to grant users
the right to modify and redistribute the software governed by this
license within the framework of an open source distribution model.
The exercising of this right is conditional upon certain obligations for
users so as to preserve this status for all subsequent redistributions.
In consideration of access to the source code and the rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors only have limited liability.
In this respect, the risks associated with loading, using, modifying
and/or developing or reproducing the software by the user are brought to
the user's attention, given its Free Software status, which may make it
complicated to use, with the result that its use is reserved for
developers and experienced professionals having in-depth computer
knowledge. Users are therefore encouraged to load and test the
suitability of the software as regards their requirements in conditions
enabling the security of their systems and/or data to be ensured and,
more generally, to use and operate it in the same conditions of
security. This Agreement may be freely reproduced and published,
provided it is not altered, and that no provisions are either added or
removed herefrom.
This Agreement may apply to any or all software for which the holder of
the economic rights decides to submit the use thereof to its provisions.
Frequently asked questions can be found on the official website of the
CeCILL licenses family (http://www.cecill.info/index.en.html) for any
necessary clarification.
Article 1 - DEFINITIONS
For the purpose of this Agreement, when the following expressions
commence with a capital letter, they shall have the following meaning:
Agreement: means this license agreement, and its possible subsequent
versions and annexes.
Software: means the software in its Object Code and/or Source Code form
and, where applicable, its documentation, "as is" when the Licensee
accepts the Agreement.
Initial Software: means the Software in its Source Code and possibly its
Object Code form and, where applicable, its documentation, "as is" when
it is first distributed under the terms and conditions of the Agreement.
Modified Software: means the Software modified by at least one
Contribution.
Source Code: means all the Software's instructions and program lines to
which access is required so as to modify the Software.
Object Code: means the binary files originating from the compilation of
the Source Code.
Holder: means the holder(s) of the economic rights over the Initial
Software.
Licensee: means the Software user(s) having accepted the Agreement.
Contributor: means a Licensee having made at least one Contribution.
Licensor: means the Holder, or any other individual or legal entity, who
distributes the Software under the Agreement.
Contribution: means any or all modifications, corrections, translations,
adaptations and/or new functions integrated into the Software by any or
all Contributors, as well as any or all Internal Modules.
Module: means a set of sources files including their documentation that
enables supplementary functions or services in addition to those offered
by the Software.
External Module: means any or all Modules, not derived from the
Software, so that this Module and the Software run in separate address
spaces, with one calling the other when they are run.
Internal Module: means any or all Module, connected to the Software so
that they both execute in the same address space.
GNU GPL: means the GNU General Public License version 2 or any
subsequent version, as published by the Free Software Foundation Inc.
GNU Affero GPL: means the GNU Affero General Public License version 3 or
any subsequent version, as published by the Free Software Foundation Inc.
EUPL: means the European Union Public License version 1.1 or any
subsequent version, as published by the European Commission.
Parties: mean both the Licensee and the Licensor.
These expressions may be used both in singular and plural form.
Article 2 - PURPOSE
The purpose of the Agreement is the grant by the Licensor to the
Licensee of a non-exclusive, transferable and worldwide license for the
Software as set forth in Article 5 <#scope> hereinafter for the whole
term of the protection granted by the rights over said Software.
Article 3 - ACCEPTANCE
3.1 The Licensee shall be deemed as having accepted the terms and
conditions of this Agreement upon the occurrence of the first of the
following events:
* (i) loading the Software by any or all means, notably, by
downloading from a remote server, or by loading from a physical medium;
* (ii) the first time the Licensee exercises any of the rights granted
hereunder.
3.2 One copy of the Agreement, containing a notice relating to the
characteristics of the Software, to the limited warranty, and to the
fact that its use is restricted to experienced users has been provided
to the Licensee prior to its acceptance as set forth in Article 3.1
<#accepting> hereinabove, and the Licensee hereby acknowledges that it
has read and understood it.
Article 4 - EFFECTIVE DATE AND TERM
4.1 EFFECTIVE DATE
The Agreement shall become effective on the date when it is accepted by
the Licensee as set forth in Article 3.1 <#accepting>.
4.2 TERM
The Agreement shall remain in force for the entire legal term of
protection of the economic rights over the Software.
Article 5 - SCOPE OF RIGHTS GRANTED
The Licensor hereby grants to the Licensee, who accepts, the following
rights over the Software for any or all use, and for the term of the
Agreement, on the basis of the terms and conditions set forth hereinafter.
Besides, if the Licensor owns or comes to own one or more patents
protecting all or part of the functions of the Software or of its
components, the Licensor undertakes not to enforce the rights granted by
these patents against successive Licensees using, exploiting or
modifying the Software. If these patents are transferred, the Licensor
undertakes to have the transferees subscribe to the obligations set
forth in this paragraph.
5.1 RIGHT OF USE
The Licensee is authorized to use the Software, without any limitation
as to its fields of application, with it being hereinafter specified
that this comprises:
1. permanent or temporary reproduction of all or part of the Software
by any or all means and in any or all form.
2. loading, displaying, running, or storing the Software on any or all
medium.
3. entitlement to observe, study or test its operation so as to
determine the ideas and principles behind any or all constituent
elements of said Software. This shall apply when the Licensee
carries out any or all loading, displaying, running, transmission or
storage operation as regards the Software, that it is entitled to
carry out hereunder.
5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS
The right to make Contributions includes the right to translate, adapt,
arrange, or make any or all modifications to the Software, and the right
to reproduce the resulting software.
The Licensee is authorized to make any or all Contributions to the
Software provided that it includes an explicit notice that it is the
author of said Contribution and indicates the date of the creation thereof.
5.3 RIGHT OF DISTRIBUTION
In particular, the right of distribution includes the right to publish,
transmit and communicate the Software to the general public on any or
all medium, and by any or all means, and the right to market, either in
consideration of a fee, or free of charge, one or more copies of the
Software by any means.
The Licensee is further authorized to distribute copies of the modified
or unmodified Software to third parties according to the terms and
conditions set forth hereinafter.
5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION
The Licensee is authorized to distribute true copies of the Software in
Source Code or Object Code form, provided that said distribution
complies with all the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty
and liability as set forth in Articles 8 and 9,
and that, in the event that only the Object Code of the Software is
redistributed, the Licensee allows effective access to the full Source
Code of the Software for a period of at least three years from the
distribution of the Software, it being understood that the additional
acquisition cost of the Source Code shall not exceed the cost of the
data transfer.
5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE
When the Licensee makes a Contribution to the Software, the terms and
conditions for the distribution of the resulting Modified Software
become subject to all the provisions of this Agreement.
The Licensee is authorized to distribute the Modified Software, in
source code or object code form, provided that said distribution
complies with all the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty
and liability as set forth in Articles 8 and 9,
and, in the event that only the object code of the Modified Software is
redistributed,
3. a note stating the conditions of effective access to the full source
code of the Modified Software for a period of at least three years
from the distribution of the Modified Software, it being understood
that the additional acquisition cost of the source code shall not
exceed the cost of the data transfer.
5.3.3 DISTRIBUTION OF EXTERNAL MODULES
When the Licensee has developed an External Module, the terms and
conditions of this Agreement do not apply to said External Module, that
may be distributed under a separate license agreement.
5.3.4 COMPATIBILITY WITH OTHER LICENSES
The Licensee can include a code that is subject to the provisions of one
of the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the
Modified or unmodified Software, and distribute that entire code under
the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.
The Licensee can include the Modified or unmodified Software in a code
that is subject to the provisions of one of the versions of the GNU GPL,
GNU Affero GPL and/or EUPL and distribute that entire code under the
terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.
Article 6 - INTELLECTUAL PROPERTY
6.1 OVER THE INITIAL SOFTWARE
The Holder owns the economic rights over the Initial Software. Any or
all use of the Initial Software is subject to compliance with the terms
and conditions under which the Holder has elected to distribute its work
and no one shall be entitled to modify the terms and conditions for the
distribution of said Initial Software.
The Holder undertakes that the Initial Software will remain ruled at
least by this Agreement, for the duration set forth in Article 4.2 <#term>.
6.2 OVER THE CONTRIBUTIONS
The Licensee who develops a Contribution is the owner of the
intellectual property rights over this Contribution as defined by
applicable law.
6.3 OVER THE EXTERNAL MODULES
The Licensee who develops an External Module is the owner of the
intellectual property rights over this External Module as defined by
applicable law and is free to choose the type of agreement that shall
govern its distribution.
6.4 JOINT PROVISIONS
The Licensee expressly undertakes:
1. not to remove, or modify, in any manner, the intellectual property
notices attached to the Software;
2. to reproduce said notices, in an identical manner, in the copies of
the Software modified or not.
The Licensee undertakes not to directly or indirectly infringe the
intellectual property rights on the Software of the Holder and/or
Contributors, and to take, where applicable, vis-à-vis its staff, any
and all measures required to ensure respect of said intellectual
property rights of the Holder and/or Contributors.
Article 7 - RELATED SERVICES
7.1 Under no circumstances shall the Agreement oblige the Licensor to
provide technical assistance or maintenance services for the Software.
However, the Licensor is entitled to offer this type of services. The
terms and conditions of such technical assistance, and/or such
maintenance, shall be set forth in a separate instrument. Only the
Licensor offering said maintenance and/or technical assistance services
shall incur liability therefor.
7.2 Similarly, any Licensor is entitled to offer to its licensees, under
its sole responsibility, a warranty, that shall only be binding upon
itself, for the redistribution of the Software and/or the Modified
Software, under terms and conditions that it is free to decide. Said
warranty, and the financial terms and conditions of its application,
shall be subject of a separate instrument executed between the Licensor
and the Licensee.
Article 8 - LIABILITY
8.1 Subject to the provisions of Article 8.2, the Licensee shall be
entitled to claim compensation for any direct loss it may have suffered
from the Software as a result of a fault on the part of the relevant
Licensor, subject to providing evidence thereof.
8.2 The Licensor's liability is limited to the commitments made under
this Agreement and shall not be incurred as a result of in particular:
(i) loss due the Licensee's total or partial failure to fulfill its
obligations, (ii) direct or consequential loss that is suffered by the
Licensee due to the use or performance of the Software, and (iii) more
generally, any consequential loss. In particular the Parties expressly
agree that any or all pecuniary or business loss (i.e. loss of data,
loss of profits, operating loss, loss of customers or orders,
opportunity cost, any disturbance to business activities) or any or all
legal proceedings instituted against the Licensee by a third party,
shall constitute consequential loss and shall not provide entitlement to
any or all compensation from the Licensor.
Article 9 - WARRANTY
9.1 The Licensee acknowledges that the scientific and technical
state-of-the-art when the Software was distributed did not enable all
possible uses to be tested and verified, nor for the presence of
possible defects to be detected. In this respect, the Licensee's
attention has been drawn to the risks associated with loading, using,
modifying and/or developing and reproducing the Software which are
reserved for experienced users.
The Licensee shall be responsible for verifying, by any or all means,
the suitability of the product for its requirements, its good working
order, and for ensuring that it shall not cause damage to either persons
or properties.
9.2 The Licensor hereby represents, in good faith, that it is entitled
to grant all the rights over the Software (including in particular the
rights set forth in Article 5 <#scope>).
9.3 The Licensee acknowledges that the Software is supplied "as is" by
the Licensor without any other express or tacit warranty, other than
that provided for in Article 9.2 <#good-faith> and, in particular,
without any warranty as to its commercial value, its secured, safe,
innovative or relevant nature.
Specifically, the Licensor does not warrant that the Software is free
from any error, that it will operate without interruption, that it will
be compatible with the Licensee's own equipment and software
configuration, nor that it will meet the Licensee's requirements.
9.4 The Licensor does not either expressly or tacitly warrant that the
Software does not infringe any third party intellectual property right
relating to a patent, software or any other property right. Therefore,
the Licensor disclaims any and all liability towards the Licensee
arising out of any or all proceedings for infringement that may be
instituted in respect of the use, modification and redistribution of the
Software. Nevertheless, should such proceedings be instituted against
the Licensee, the Licensor shall provide it with technical and legal
expertise for its defense. Such technical and legal expertise shall be
decided on a case-by-case basis between the relevant Licensor and the
Licensee pursuant to a memorandum of understanding. The Licensor
disclaims any and all liability as regards the Licensee's use of the
name of the Software. No warranty is given as regards the existence of
prior rights over the name of the Software or as regards the existence
of a trademark.
Article 10 - TERMINATION
10.1 In the event of a breach by the Licensee of its obligations
hereunder, the Licensor may automatically terminate this Agreement
thirty (30) days after notice has been sent to the Licensee and has
remained ineffective.
10.2 A Licensee whose Agreement is terminated shall no longer be
authorized to use, modify or distribute the Software. However, any
licenses that it may have granted prior to termination of the Agreement
shall remain valid subject to their having been granted in compliance
with the terms and conditions hereof.
Article 11 - MISCELLANEOUS
11.1 EXCUSABLE EVENTS
Neither Party shall be liable for any or all delay, or failure to
perform the Agreement, that may be attributable to an event of force
majeure, an act of God or an outside cause, such as defective
functioning or interruptions of the electricity or telecommunications
networks, network paralysis following a virus attack, intervention by
government authorities, natural disasters, water damage, earthquakes,
fire, explosions, strikes and labor unrest, war, etc.
11.2 Any failure by either Party, on one or more occasions, to invoke
one or more of the provisions hereof, shall under no circumstances be
interpreted as being a waiver by the interested Party of its right to
invoke said provision(s) subsequently.
11.3 The Agreement cancels and replaces any or all previous agreements,
whether written or oral, between the Parties and having the same
purpose, and constitutes the entirety of the agreement between said
Parties concerning said purpose. No supplement or modification to the
terms and conditions hereof shall be effective as between the Parties
unless it is made in writing and signed by their duly authorized
representatives.
11.4 In the event that one or more of the provisions hereof were to
conflict with a current or future applicable act or legislative text,
said act or legislative text shall prevail, and the Parties shall make
the necessary amendments so as to comply with said act or legislative
text. All other provisions shall remain effective. Similarly, invalidity
of a provision of the Agreement, for any reason whatsoever, shall not
cause the Agreement as a whole to be invalid.
11.5 LANGUAGE
The Agreement is drafted in both French and English and both versions
are deemed authentic.
Article 12 - NEW VERSIONS OF THE AGREEMENT
12.1 Any person is authorized to duplicate and distribute copies of this
Agreement.
12.2 So as to ensure coherence, the wording of this Agreement is
protected and may only be modified by the authors of the License, who
reserve the right to periodically publish updates or new versions of the
Agreement, each with a separate number. These subsequent versions may
address new issues encountered by Free Software.
12.3 Any Software distributed under a given version of the Agreement may
only be subsequently distributed under the same version of the Agreement
or a subsequent version, subject to the provisions of Article 5.3.4
<#compatibility>.
Article 13 - GOVERNING LAW AND JURISDICTION
13.1 The Agreement is governed by French law. The Parties agree to
endeavor to seek an amicable solution to any disagreements or disputes
that may arise during the performance of the Agreement.
13.2 Failing an amicable solution within two (2) months as from their
occurrence, and unless emergency proceedings are necessary, the
disagreements or disputes shall be referred to the Paris Courts having
jurisdiction, by the more diligent Party.

147
gclc-swt/src/main/java/fr/bigeon/gclc/swt/ConsoleDelayIO.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/ConsoleDelayIO.java
View File

@ -1,57 +1,90 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.ConsoleDelayIO.java * gclc-swt:net.bigeon.gclc.swt.ConsoleDelayIO.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
/** This class represents an object used to send commands to a console /*-
* application. * #%L
* <p> * GCLC swt
* The sending of command is done in two phases. Define the input through get * %%
* and set, and then validate the input. * Copyright (C) 2015 - 2018 Bigeon
* * %%
* @author Emmanuel Bigeon */ * This software is governed by the CeCILL license under French law and
public interface ConsoleDelayIO { * abiding by the rules of distribution of free software. You can use,
/** Get the input text. * modify and/ or redistribute the software under the terms of the CeCILL
* @return the non validated input */ * license as circulated by CEA, CNRS and INRIA at the following URL
String getInput(); * "http://www.cecill.info".
*
/** Set the input text. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @param input the input to set */ * with a limited warranty and the software's author, the holder of the
void setInput(String input); * economic rights, and the successive licensors have only limited
* liability.
/** Actually send the input as the prompt next input. */ *
void validateInput(); * In this respect, the user's attention is drawn to the risks associated
} * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
/** This class represents an object used to send commands to a console
* application.
* <p>
* The sending of command is done in two phases. Define the input through get
* and set, and then validate the input.
*
* @author Emmanuel Bigeon */
public interface ConsoleDelayIO {
/** Get the input text.
* @return the non validated input */
String getInput();
/** Set the input text.
*
* @param input the input to set */
void setInput(String input);
/** Actually send the input as the prompt next input. */
void validateInput();
}

257
gclc-swt/src/main/java/fr/bigeon/gclc/swt/HistoryTextKeyListener.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/HistoryTextKeyListener.java
View File

@ -1,112 +1,145 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.HistoryTextKeyListener.java * gclc-swt:net.bigeon.gclc.swt.HistoryTextKeyListener.java
* Created on: Jun 9, 2016 * Created on: Jun 9, 2016
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import org.eclipse.swt.SWT; /*-
import org.eclipse.swt.events.KeyAdapter; * #%L
import org.eclipse.swt.events.KeyEvent; * GCLC swt
* %%
import net.bigeon.collections.ArrayRibbon; * Copyright (C) 2015 - 2018 Bigeon
import net.bigeon.collections.Ribbon; * %%
* This software is governed by the CeCILL license under French law and
/** A key listener to validate commands and manage the history of commands. * abiding by the rules of distribution of free software. You can use,
* * modify and/ or redistribute the software under the terms of the CeCILL
* @author Emmanuel Bigeon */ * license as circulated by CEA, CNRS and INRIA at the following URL
public final class HistoryTextKeyListener extends KeyAdapter { * "http://www.cecill.info".
*
/** The size of commands history. */ * As a counterpart to the access to the source code and rights to copy,
private static final int DEFAULT_HISTORY_SIZE = 10; * modify and redistribute granted by the license, users are provided only
/** The empty string constant. */ * with a limited warranty and the software's author, the holder of the
private static final String EMPTY = ""; //$NON-NLS-1$ * economic rights, and the successive licensors have only limited
/** The history ribbon. */ * liability.
private final Ribbon<String> commands; *
/** The current index in history search. */ * In this respect, the user's attention is drawn to the risks associated
private int currentIndex = 0; * with loading, using, modifying and/or developing or reproducing the
/** The console to notify of command validation. */ * software by the user in light of its specific status of free software,
private final ConsoleDelayIO console; * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** Create the key listener that cycle the history. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* @param console the console delayed */ * requirements in conditions enabling the security of their systems and/or
public HistoryTextKeyListener(final ConsoleDelayIO console) { * data to be ensured and, more generally, to use and operate it in the
super(); * same conditions as regards security.
this.console = console; *
commands = new ArrayRibbon<>(DEFAULT_HISTORY_SIZE); * The fact that you are presently reading this means that you have had
} * knowledge of the CeCILL license and that you accept its terms.
* #L%
/* (non-Javadoc) */
* @see org.eclipse.swt.events.KeyAdapter#keyPressed(org.eclipse.swt.events. import org.eclipse.swt.SWT;
* KeyEvent) */ import org.eclipse.swt.events.KeyAdapter;
@Override import org.eclipse.swt.events.KeyEvent;
public void keyPressed(final KeyEvent e) {
pressedKeyCode(e.keyCode); import net.bigeon.collections.ArrayRibbon;
} import net.bigeon.collections.Ribbon;
/** Indicate a pressed key combination. /** A key listener to validate commands and manage the history of commands.
* *
* @param keyCode the pressed key code */ * @author Emmanuel Bigeon */
public void pressedKeyCode(final int keyCode) { public final class HistoryTextKeyListener extends KeyAdapter {
// Enter validates the command if prompting
if (keyCode == '\r') { /** The size of commands history. */
final String input = console.getInput(); private static final int DEFAULT_HISTORY_SIZE = 10;
if (!input.isEmpty()) { /** The empty string constant. */
commands.add(input); private static final String EMPTY = ""; //$NON-NLS-1$
} /** The history ribbon. */
console.validateInput(); private final Ribbon<String> commands;
currentIndex = -1; /** The current index in history search. */
} private int currentIndex = 0;
/** The console to notify of command validation. */
// Upper arrow retrieves previous commands private final ConsoleDelayIO console;
if (keyCode == SWT.ARROW_UP &&
currentIndex < commands.size() - 1) { /** Create the key listener that cycle the history.
currentIndex++; *
final String cmd = commands.get(commands.size() - currentIndex - 1); * @param console the console delayed */
console.setInput(cmd); public HistoryTextKeyListener(final ConsoleDelayIO console) {
} super();
this.console = console;
// Lower arrow retrieves next commands commands = new ArrayRibbon<>(DEFAULT_HISTORY_SIZE);
if (keyCode == SWT.ARROW_DOWN) { }
if (currentIndex == 0) {
currentIndex--; /* (non-Javadoc)
console.setInput(EMPTY); * @see org.eclipse.swt.events.KeyAdapter#keyPressed(org.eclipse.swt.events.
} else if (currentIndex > 0) { * KeyEvent) */
final String cmd = commands @Override
.get(commands.size() - (--currentIndex) - 1); public void keyPressed(final KeyEvent e) {
console.setInput(cmd); pressedKeyCode(e.keyCode);
} }
}
} /** Indicate a pressed key combination.
} *
* @param keyCode the pressed key code */
public void pressedKeyCode(final int keyCode) {
// Enter validates the command if prompting
if (keyCode == '\r') {
final String input = console.getInput();
if (!input.isEmpty()) {
commands.add(input);
}
console.validateInput();
currentIndex = -1;
}
// Upper arrow retrieves previous commands
if (keyCode == SWT.ARROW_UP &&
currentIndex < commands.size() - 1) {
currentIndex++;
final String cmd = commands.get(commands.size() - currentIndex - 1);
console.setInput(cmd);
}
// Lower arrow retrieves next commands
if (keyCode == SWT.ARROW_DOWN) {
if (currentIndex == 0) {
currentIndex--;
console.setInput(EMPTY);
} else if (currentIndex > 0) {
final String cmd = commands
.get(commands.size() - (--currentIndex) - 1);
console.setInput(cmd);
}
}
}
}

905
gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsole.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsole.java
View File

@ -1,436 +1,469 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.SWTConsole.java * gclc-swt:net.bigeon.gclc.swt.SWTConsole.java
* Created on: Apr 18, 2015 * Created on: Apr 18, 2015
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import java.io.IOException; /*-
import java.util.logging.Level; * #%L
import java.util.logging.Logger; * GCLC swt
* %%
import org.eclipse.swt.SWT; * Copyright (C) 2015 - 2018 Bigeon
import org.eclipse.swt.layout.GridData; * %%
import org.eclipse.swt.layout.GridLayout; * This software is governed by the CeCILL license under French law and
import org.eclipse.swt.widgets.Composite; * abiding by the rules of distribution of free software. You can use,
import org.eclipse.swt.widgets.Display; * modify and/ or redistribute the software under the terms of the CeCILL
import org.eclipse.swt.widgets.Label; * license as circulated by CEA, CNRS and INRIA at the following URL
import org.eclipse.swt.widgets.Text; * "http://www.cecill.info".
*
import net.bigeon.gclc.ConsoleApplication; * As a counterpart to the access to the source code and rights to copy,
import net.bigeon.gclc.manager.ConsoleInput; * modify and redistribute granted by the license, users are provided only
import net.bigeon.gclc.manager.ConsoleOutput; * with a limited warranty and the software's author, the holder of the
import net.bigeon.gclc.tools.ConstantString; * economic rights, and the successive licensors have only limited
import net.bigeon.gclc.tools.StringProvider; * liability.
*
/** A SWT component to connect to gclc {@link ConsoleApplication}. * In this respect, the user's attention is drawn to the risks associated
* <p> * with loading, using, modifying and/or developing or reproducing the
* * software by the user in light of its specific status of free software,
* @author Emmanuel Bigeon */ * that may mean that it is complicated to manipulate, and that also
public final class SWTConsole extends Composite * therefore means that it is reserved for developers and experienced
implements ConsoleDelayIO, ConsoleInput, ConsoleOutput { * professionals having in-depth computer knowledge. Users are therefore
/** The number of columns of the layout. */ * encouraged to load and test the software's suitability as regards their
private static final int LAYOUT_NB_COLUMNS = 2; * requirements in conditions enabling the security of their systems and/or
/** The cmd prefix in the output console. */ * data to be ensured and, more generally, to use and operate it in the
private static final String CMD_PREFIX = "[CMD] "; //$NON-NLS-1$ * same conditions as regards security.
/** The class logger. */ *
private static final Logger LOGGER = Logger * The fact that you are presently reading this means that you have had
.getLogger(SWTConsole.class.getName()); * knowledge of the CeCILL license and that you accept its terms.
/** The empty string constant. */ * #L%
private static final String EMPTY = ""; //$NON-NLS-1$ */
/** The console output text field. */ import java.io.IOException;
private final Text consoleOutput; import java.util.logging.Level;
/** The console input text field. */ import java.util.logging.Logger;
private final Text consoleInput;
/** The prompt label. */ import org.eclipse.swt.SWT;
private final Label lblPromptlabel; import org.eclipse.swt.layout.GridData;
/** The prompt text. */ import org.eclipse.swt.layout.GridLayout;
private StringProvider prompt = new ConstantString("> "); //$NON-NLS-1$ import org.eclipse.swt.widgets.Composite;
/** The command entered by the user. */ import org.eclipse.swt.widgets.Display;
private String command = null; import org.eclipse.swt.widgets.Label;
/** If the prompt should be active. */ import org.eclipse.swt.widgets.Text;
private boolean prompting = false;
/** The object for thread synchronization with the prompt. */ import net.bigeon.gclc.ConsoleApplication;
private final Object promptLock = new Object(); import net.bigeon.gclc.manager.ConsoleInput;
import net.bigeon.gclc.manager.ConsoleOutput;
/** Create the composite. import net.bigeon.gclc.tools.ConstantString;
* import net.bigeon.gclc.tools.StringProvider;
* @param parent the prent composite
* @param style the composite style */ /** A SWT component to connect to gclc {@link ConsoleApplication}.
public SWTConsole(final Composite parent, final int style) { * <p>
super(parent, style); *
* @author Emmanuel Bigeon */
setLayout(new GridLayout(LAYOUT_NB_COLUMNS, false)); public final class SWTConsole extends Composite
implements ConsoleDelayIO, ConsoleInput, ConsoleOutput {
consoleOutput = new Text(this, /** The number of columns of the layout. */
SWT.BORDER | SWT.READ_ONLY | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI); private static final int LAYOUT_NB_COLUMNS = 2;
consoleOutput.setLayoutData( /** The cmd prefix in the output console. */
new GridData(SWT.FILL, SWT.FILL, true, true, LAYOUT_NB_COLUMNS, 1)); private static final String CMD_PREFIX = "[CMD] "; //$NON-NLS-1$
consoleOutput.setRedraw(true); /** The class logger. */
private static final Logger LOGGER = Logger
lblPromptlabel = new Label(this, SWT.NONE); .getLogger(SWTConsole.class.getName());
lblPromptlabel.setText(prompt.apply()); /** The empty string constant. */
private static final String EMPTY = ""; //$NON-NLS-1$
consoleInput = new Text(this, SWT.BORDER); /** The console output text field. */
consoleInput.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); private final Text consoleOutput;
consoleInput.addKeyListener(new HistoryTextKeyListener(this)); /** The console input text field. */
private final Text consoleInput;
} /** The prompt label. */
private final Label lblPromptlabel;
@Override /** The prompt text. */
protected void checkSubclass() { private StringProvider prompt = new ConstantString("> "); //$NON-NLS-1$
// Disable the check that prevents subclassing of SWT components /** The command entered by the user. */
} private String command = null;
/** If the prompt should be active. */
/* (non-Javadoc) private boolean prompting = false;
* @see fr.bigeon.gclc.manager.ConsoleManager#close() */ /** The object for thread synchronization with the prompt. */
@Override private final Object promptLock = new Object();
public void close() {
synchronized (promptLock) { /** Create the composite.
prompting = false; *
promptLock.notifyAll(); * @param parent the prent composite
} * @param style the composite style */
if (consoleInput.isDisposed()) { public SWTConsole(final Composite parent, final int style) {
return; super(parent, style);
}
consoleInput.setEnabled(false); setLayout(new GridLayout(LAYOUT_NB_COLUMNS, false));
consoleOutput.setEnabled(false);
} consoleOutput = new Text(this,
SWT.BORDER | SWT.READ_ONLY | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI);
/* (non-Javadoc) consoleOutput.setLayoutData(
* @see fr.bigeon.gclc.swt.ConsoleDelayIO#getInput() */ new GridData(SWT.FILL, SWT.FILL, true, true, LAYOUT_NB_COLUMNS, 1));
@Override consoleOutput.setRedraw(true);
public String getInput() {
return consoleInput.getText(); lblPromptlabel = new Label(this, SWT.NONE);
} lblPromptlabel.setText(prompt.apply());
/* (non-Javadoc) consoleInput = new Text(this, SWT.BORDER);
* @see fr.bigeon.gclc.ConsoleManager#getPrompt() */ consoleInput.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
@Override consoleInput.addKeyListener(new HistoryTextKeyListener(this));
public StringProvider getPrompt() {
return prompt; }
}
@Override
/* (non-Javadoc) protected void checkSubclass() {
* @see fr.bigeon.gclc.manager.ConsoleManager#interruptPrompt() */ // Disable the check that prevents subclassing of SWT components
@Override }
public void interruptPrompt() {
synchronized (promptLock) { /* (non-Javadoc)
promptLock.notifyAll(); * @see fr.bigeon.gclc.manager.ConsoleManager#close() */
} @Override
} public void close() {
synchronized (promptLock) {
/* (non-Javadoc) prompting = false;
* @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */ promptLock.notifyAll();
@Override }
public boolean isClosed() { if (consoleInput.isDisposed()) {
return isDisposed(); return;
} }
consoleInput.setEnabled(false);
/* (non-Javadoc) consoleOutput.setEnabled(false);
* @see fr.bigeon.gclc.ConsoleManager#print(java.lang.String) */ }
@Override
public void print(final String text) throws IOException { /* (non-Javadoc)
if (isDisposed()) { * @see net.bigeon.gclc.swt.ConsoleDelayIO#getInput() */
throw new IOException(); @Override
} public String getInput() {
Display.getDefault().syncExec(new Runnable() { return consoleInput.getText();
@SuppressWarnings("synthetic-access") }
@Override
public void run() { /* (non-Javadoc)
if (!consoleOutput.isDisposed()) { * @see fr.bigeon.gclc.ConsoleManager#getPrompt() */
consoleOutput.append(text); @Override
} public StringProvider getPrompt() {
} return prompt;
}); }
}
/* (non-Javadoc)
/* (non-Javadoc) * @see fr.bigeon.gclc.manager.ConsoleManager#interruptPrompt() */
* @see fr.bigeon.gclc.ConsoleManager#println() */ @Override
@Override public void interruptPrompt() {
public void println() throws IOException { synchronized (promptLock) {
if (isDisposed()) { promptLock.notifyAll();
throw new IOException(); }
} }
Display.getDefault().syncExec(new Runnable() {
@SuppressWarnings("synthetic-access") /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */
public void run() { @Override
if (!consoleOutput.isDisposed()) { public boolean isClosed() {
consoleOutput.append(System.lineSeparator()); return isDisposed();
} }
}
}); /* (non-Javadoc)
} * @see fr.bigeon.gclc.ConsoleManager#print(java.lang.String) */
@Override
/* (non-Javadoc) public void print(final String text) throws IOException {
* @see fr.bigeon.gclc.ConsoleManager#println(java.lang.String) */ if (isDisposed()) {
@Override throw new IOException();
public void println(final String message) throws IOException { }
if (isDisposed()) { Display.getDefault().syncExec(new Runnable() {
throw new IOException(); @SuppressWarnings("synthetic-access")
} @Override
Display.getDefault().syncExec(new Runnable() { public void run() {
@SuppressWarnings("synthetic-access") if (!consoleOutput.isDisposed()) {
@Override consoleOutput.append(text);
public void run() { }
if (!consoleOutput.isDisposed()) { }
consoleOutput.append(message + System.lineSeparator()); });
} }
}
}); /* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#println() */
} @Override
public void println() throws IOException {
/* (non-Javadoc) if (isDisposed()) {
* @see fr.bigeon.gclc.ConsoleManager#prompt() */ throw new IOException();
@Override }
public String prompt() throws IOException { Display.getDefault().syncExec(new Runnable() {
synchronized (promptLock) { @SuppressWarnings("synthetic-access")
if (isDisposed()) { @Override
throw new IOException(); public void run() {
} if (!consoleOutput.isDisposed()) {
try { consoleOutput.append(System.lineSeparator());
Display.getDefault().syncExec(new Runnable() { }
@Override }
public void run() { });
if (!consoleInput.isDisposed()) { }
consoleInput.setEnabled(true);
lblPromptlabel.setText(prompt.apply()); /* (non-Javadoc)
// relayout * @see fr.bigeon.gclc.ConsoleManager#println(java.lang.String) */
SWTConsole.this.layout(); @Override
consoleInput.setFocus(); public void println(final String message) throws IOException {
} if (isDisposed()) {
} throw new IOException();
}); }
prompting = true; Display.getDefault().syncExec(new Runnable() {
promptLock.notifyAll(); @SuppressWarnings("synthetic-access")
while (prompting) { @Override
promptLock.wait(); public void run() {
} if (!consoleOutput.isDisposed()) {
} catch (final InterruptedException e) { consoleOutput.append(message + System.lineSeparator());
LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$ }
command = null; }
Thread.currentThread().interrupt(); });
}
} }
if (isDisposed()) {
throw new IOException("Input closed"); //$NON-NLS-1$ /* (non-Javadoc)
} * @see fr.bigeon.gclc.ConsoleManager#prompt() */
return command; @Override
} public String prompt() throws IOException {
synchronized (promptLock) {
/* (non-Javadoc) if (isDisposed()) {
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */ throw new IOException();
@Override }
public String prompt(final long timeout) throws IOException { try {
synchronized (promptLock) { Display.getDefault().syncExec(new Runnable() {
if (isDisposed()) { @Override
throw new IOException(); public void run() {
} if (!consoleInput.isDisposed()) {
try { consoleInput.setEnabled(true);
Display.getDefault().syncExec(new Runnable() { lblPromptlabel.setText(prompt.apply());
@Override // relayout
public void run() { SWTConsole.this.layout();
if (!consoleInput.isDisposed()) { consoleInput.setFocus();
consoleInput.setEnabled(true); }
lblPromptlabel.setText(prompt.apply()); }
// relayout });
SWTConsole.this.layout(); prompting = true;
consoleInput.setFocus(); promptLock.notifyAll();
} while (prompting) {
} promptLock.wait();
}); }
prompting = true; } catch (final InterruptedException e) {
command = null; LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
promptLock.notifyAll(); command = null;
final long start = System.currentTimeMillis(); Thread.currentThread().interrupt();
long cur = start; }
while (prompting && start + timeout>cur) { }
promptLock.wait((cur-start-timeout)/2); if (isDisposed()) {
cur = System.currentTimeMillis(); throw new IOException("Input closed"); //$NON-NLS-1$
} }
} catch (final InterruptedException e) { return command;
LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$ }
command = null;
Thread.currentThread().interrupt(); /* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
} @Override
if (isDisposed()) { public String prompt(final long timeout) throws IOException {
throw new IOException("Input closed"); //$NON-NLS-1$ synchronized (promptLock) {
} if (isDisposed()) {
return command; throw new IOException();
} }
try {
/* (non-Javadoc) Display.getDefault().syncExec(new Runnable() {
* @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */ @Override
@Override public void run() {
public String prompt(final String message) throws IOException { if (!consoleInput.isDisposed()) {
synchronized (promptLock) { consoleInput.setEnabled(true);
if (isDisposed()) { lblPromptlabel.setText(prompt.apply());
throw new IOException(); // relayout
} SWTConsole.this.layout();
try { consoleInput.setFocus();
Display.getDefault().syncExec(new Runnable() { }
@SuppressWarnings("synthetic-access") }
@Override });
public void run() { prompting = true;
if (!consoleOutput.isDisposed()) { command = null;
lblPromptlabel.setText(message); promptLock.notifyAll();
// relayout final long start = System.currentTimeMillis();
SWTConsole.this.layout(); long cur = start;
consoleInput.setEnabled(true); while (prompting && start + timeout>cur) {
consoleInput.setFocus(); promptLock.wait((cur-start-timeout)/2);
} cur = System.currentTimeMillis();
} }
}); } catch (final InterruptedException e) {
prompting = true; LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
promptLock.wait(); command = null;
if (isDisposed()) { Thread.currentThread().interrupt();
throw new IOException(); }
} }
} catch (final InterruptedException e) { if (isDisposed()) {
LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$ throw new IOException("Input closed"); //$NON-NLS-1$
command = null; }
Thread.currentThread().interrupt(); return command;
} finally { }
Display.getDefault().syncExec(new Runnable() {
@SuppressWarnings("synthetic-access") /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */
public void run() { @Override
if (!consoleOutput.isDisposed()) { public String prompt(final String message) throws IOException {
lblPromptlabel.setText(prompt.apply()); synchronized (promptLock) {
// relayout if (isDisposed()) {
SWTConsole.this.layout(); throw new IOException();
} }
} try {
}); Display.getDefault().syncExec(new Runnable() {
} @SuppressWarnings("synthetic-access")
} @Override
return command; public void run() {
} if (!consoleOutput.isDisposed()) {
lblPromptlabel.setText(message);
/* (non-Javadoc) // relayout
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long) */ SWTConsole.this.layout();
@Override consoleInput.setEnabled(true);
public String prompt(final String message, final long timeout) throws IOException { consoleInput.setFocus();
// TODO Auto-generated method stub }
// return null; }
throw new RuntimeException("Not implemented yet"); });
} prompting = true;
promptLock.wait();
/* (non-Javadoc) if (isDisposed()) {
* @see org.eclipse.swt.widgets.Composite#setFocus() */ throw new IOException();
@Override }
public boolean setFocus() { } catch (final InterruptedException e) {
return consoleInput.setFocus(); LOGGER.log(Level.WARNING, "Error in synchronization of prompting", e); //$NON-NLS-1$
} command = null;
Thread.currentThread().interrupt();
/* (non-Javadoc) } finally {
* @see fr.bigeon.gclc.swt.ConsoleDelayIO#setInput(java.lang.String) */ Display.getDefault().syncExec(new Runnable() {
@Override @SuppressWarnings("synthetic-access")
public void setInput(final String input) { @Override
consoleInput.setText(input); public void run() {
consoleInput.setSelection(input.length()); if (!consoleOutput.isDisposed()) {
} lblPromptlabel.setText(prompt.apply());
// relayout
/* (non-Javadoc) SWTConsole.this.layout();
* @see fr.bigeon.gclc.ConsoleManager#setPrompt(java.lang.String) */ }
@Override }
public void setPrompt(final StringProvider prompt) { });
this.prompt = prompt; }
Display.getDefault().syncExec(new Runnable() { }
@SuppressWarnings("synthetic-access") return command;
@Override }
public void run() {
if (!consoleOutput.isDisposed()) { /* (non-Javadoc)
lblPromptlabel.setText(prompt.apply()); * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, long) */
// relayout @Override
SWTConsole.this.layout(); public String prompt(final String message, final long timeout) throws IOException {
} // TODO Auto-generated method stub
} // return null;
}); throw new RuntimeException("Not implemented yet");
} }
@Override /* (non-Javadoc)
public void setPrompt(String prompt) { * @see org.eclipse.swt.widgets.Composite#setFocus() */
setPrompt(new ConstantString(prompt)); @Override
} public boolean setFocus() {
return consoleInput.setFocus();
/** @param string the text */ }
public void setText(final String string) {
consoleInput.setText(string); /* (non-Javadoc)
} * @see net.bigeon.gclc.swt.ConsoleDelayIO#setInput(java.lang.String) */
@Override
/** public void setInput(final String input) {
* consoleInput.setText(input);
*/ consoleInput.setSelection(input.length());
public void validateCommand() { }
validateInput();
} /* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#setPrompt(java.lang.String) */
/** @Override
* public void setPrompt(final StringProvider prompt) {
*/ this.prompt = prompt;
@Override Display.getDefault().syncExec(new Runnable() {
public void validateInput() { @SuppressWarnings("synthetic-access")
Display.getDefault().syncExec(new Runnable() { @Override
@SuppressWarnings("synthetic-access") public void run() {
@Override if (!consoleOutput.isDisposed()) {
public void run() { lblPromptlabel.setText(prompt.apply());
consoleInput.setEnabled(false); // relayout
} SWTConsole.this.layout();
}); }
synchronized (promptLock) { }
while (!prompting) { });
try { }
promptLock.wait();
} catch (final InterruptedException e) { @Override
LOGGER.log(Level.SEVERE, "Interruption while waiting prompt", e); //$NON-NLS-1$ public void setPrompt(String prompt) {
} setPrompt(new ConstantString(prompt));
} }
Display.getDefault().syncExec(new Runnable() {
@SuppressWarnings("synthetic-access") /** @param string the text */
@Override public void setText(final String string) {
public void run() { consoleInput.setText(string);
command = consoleInput.getText(); }
prompting = false;
consoleInput.setText(EMPTY); /**
consoleOutput.append(CMD_PREFIX + command + System.lineSeparator()); *
} */
}); public void validateCommand() {
promptLock.notifyAll(); validateInput();
} }
}
/**
} *
*/
@Override
public void validateInput() {
Display.getDefault().syncExec(new Runnable() {
@SuppressWarnings("synthetic-access")
@Override
public void run() {
consoleInput.setEnabled(false);
}
});
synchronized (promptLock) {
while (!prompting) {
try {
promptLock.wait();
} catch (final InterruptedException e) {
LOGGER.log(Level.SEVERE, "Interruption while waiting prompt", e); //$NON-NLS-1$
}
}
Display.getDefault().syncExec(new Runnable() {
@SuppressWarnings("synthetic-access")
@Override
public void run() {
command = consoleInput.getText();
prompting = false;
consoleInput.setText(EMPTY);
consoleOutput.append(CMD_PREFIX + command + System.lineSeparator());
}
});
promptLock.notifyAll();
}
}
}

203
gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsoleShell.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleShell.java
View File

@ -1,85 +1,118 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.SWTConsoleShell.java * gclc-swt:net.bigeon.gclc.swt.SWTConsoleShell.java
* Created on: Apr 18, 2015 * Created on: Apr 18, 2015
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import org.eclipse.swt.SWT; /*-
import org.eclipse.swt.layout.FillLayout; * #%L
import org.eclipse.swt.widgets.Display; * GCLC swt
import org.eclipse.swt.widgets.Shell; * %%
* Copyright (C) 2015 - 2018 Bigeon
/** A shell containing a {@link SWTConsole} * %%
* <p> * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel Bigeon */ * modify and/ or redistribute the software under the terms of the CeCILL
public final class SWTConsoleShell extends Shell { * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
/** The console component */ *
private SWTConsole console; * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** Create the shell. * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* @param display the display */ * liability.
public SWTConsoleShell(final Display display) { *
super(display, SWT.SHELL_TRIM); * In this respect, the user's attention is drawn to the risks associated
setLayout(new FillLayout(SWT.HORIZONTAL)); * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
createContents(); * that may mean that it is complicated to manipulate, and that also
} * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
@Override * encouraged to load and test the software's suitability as regards their
protected void checkSubclass() { * requirements in conditions enabling the security of their systems and/or
// Disable the check that prevents subclassing of SWT components * data to be ensured and, more generally, to use and operate it in the
} * same conditions as regards security.
*
/** Create contents of the shell. */ * The fact that you are presently reading this means that you have had
protected void createContents() { * knowledge of the CeCILL license and that you accept its terms.
console = new SWTConsole(this, SWT.NONE); * #L%
setText("Console Application"); //$NON-NLS-1$ */
} import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
/* (non-Javadoc) import org.eclipse.swt.widgets.Display;
* @see org.eclipse.swt.widgets.Shell#dispose() */ import org.eclipse.swt.widgets.Shell;
@Override
public void dispose() { /** A shell containing a {@link SWTConsole}
super.dispose(); * <p>
console.close(); *
} * @author Emmanuel Bigeon */
public final class SWTConsoleShell extends Shell {
/** @return the input and output. */
public SWTConsole getManager() { /** The console component */
return console; private SWTConsole console;
}
} /** Create the shell.
*
* @param display the display */
public SWTConsoleShell(final Display display) {
super(display, SWT.SHELL_TRIM);
setLayout(new FillLayout(SWT.HORIZONTAL));
createContents();
}
@Override
protected void checkSubclass() {
// Disable the check that prevents subclassing of SWT components
}
/** Create contents of the shell. */
protected void createContents() {
console = new SWTConsole(this, SWT.NONE);
setText("Console Application"); //$NON-NLS-1$
}
/* (non-Javadoc)
* @see org.eclipse.swt.widgets.Shell#dispose() */
@Override
public void dispose() {
super.dispose();
console.close();
}
/** @return the input and output. */
public SWTConsole getManager() {
return console;
}
}

413
gclc-swt/src/main/java/fr/bigeon/gclc/swt/SWTConsoleView.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/SWTConsoleView.java
View File

@ -1,190 +1,223 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.SWTConsole.java * gclc-swt:net.bigeon.gclc.swt.SWTConsole.java
* Created on: Apr 18, 2015 * Created on: Apr 18, 2015
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import java.io.IOException; /*-
import java.util.logging.Level; * #%L
import java.util.logging.Logger; * GCLC swt
* %%
import org.eclipse.swt.SWT; * Copyright (C) 2015 - 2018 Bigeon
import org.eclipse.swt.layout.GridData; * %%
import org.eclipse.swt.layout.GridLayout; * This software is governed by the CeCILL license under French law and
import org.eclipse.swt.widgets.Composite; * abiding by the rules of distribution of free software. You can use,
import org.eclipse.swt.widgets.Display; * modify and/ or redistribute the software under the terms of the CeCILL
import org.eclipse.swt.widgets.Text; * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
import net.bigeon.gclc.ConsoleApplication; *
import net.bigeon.gclc.utils.AOutputForwardRunnable; * As a counterpart to the access to the source code and rights to copy,
import net.bigeon.gclc.utils.PipedConsoleInput; * modify and redistribute granted by the license, users are provided only
import net.bigeon.gclc.utils.PipedConsoleOutput; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** A SWT component to connect to gclc {@link ConsoleApplication} * liability.
* <p> *
* * In this respect, the user's attention is drawn to the risks associated
* @author Emmanuel Bigeon */ * with loading, using, modifying and/or developing or reproducing the
public final class SWTConsoleView extends Composite implements ConsoleDelayIO { * software by the user in light of its specific status of free software,
/** The local implementation of the forwarding runnable * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @author Emmanuel Bigeon */ * professionals having in-depth computer knowledge. Users are therefore
private final class ToSWTConsoleForwardRunnable * encouraged to load and test the software's suitability as regards their
extends AOutputForwardRunnable { * requirements in conditions enabling the security of their systems and/or
/** The running status */ * data to be ensured and, more generally, to use and operate it in the
private boolean running = true; * same conditions as regards security.
*
/** @param manager the manager */ * The fact that you are presently reading this means that you have had
public ToSWTConsoleForwardRunnable(final PipedConsoleOutput manager) { * knowledge of the CeCILL license and that you accept its terms.
super(manager); * #L%
} */
import java.io.IOException;
@Override import java.util.logging.Level;
protected void forwardLine(final String m) { import java.util.logging.Logger;
appendConsoleOutput(m);
} import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
@Override import org.eclipse.swt.layout.GridLayout;
protected boolean isRunning() { import org.eclipse.swt.widgets.Composite;
return running && !isDisposed(); import org.eclipse.swt.widgets.Display;
} import org.eclipse.swt.widgets.Text;
/** @param running the running to set */ import net.bigeon.gclc.ConsoleApplication;
public void setRunning(final boolean running) { import net.bigeon.gclc.utils.AOutputForwardRunnable;
this.running = running; import net.bigeon.gclc.utils.PipedConsoleInput;
} import net.bigeon.gclc.utils.PipedConsoleOutput;
}
/** A SWT component to connect to gclc {@link ConsoleApplication}
/** The class logger */ * <p>
private static final Logger LOGGER = Logger *
.getLogger(SWTConsoleView.class.getName()); * @author Emmanuel Bigeon */
/** The console output text field */ public final class SWTConsoleView extends Composite implements ConsoleDelayIO {
private final Text consoleOutput; /** The local implementation of the forwarding runnable
/** The console input text field */ *
private final Text consoleInput; * @author Emmanuel Bigeon */
/** The input. */ private final class ToSWTConsoleForwardRunnable
private PipedConsoleInput input; extends AOutputForwardRunnable {
/** The forwarding runnable */ /** The running status */
private ToSWTConsoleForwardRunnable forward; private boolean running = true;
/** Create the composite. /** @param manager the manager */
* public ToSWTConsoleForwardRunnable(final PipedConsoleOutput manager) {
* @param parent the prent composite super(manager);
* @param style the composite style */ }
public SWTConsoleView(final Composite parent, final int style) {
super(parent, style); @Override
protected void forwardLine(final String m) {
setLayout(new GridLayout(1, false)); appendConsoleOutput(m);
}
consoleOutput = new Text(this, SWT.BORDER | SWT.READ_ONLY | SWT.WRAP |
SWT.V_SCROLL | SWT.MULTI); @Override
consoleOutput.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, protected boolean isRunning() {
1, 1)); return running && !isDisposed();
consoleOutput.setRedraw(true); }
consoleInput = new Text(this, SWT.BORDER); /** @param running the running to set */
consoleInput.setLayoutData( public void setRunning(final boolean running) {
new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1)); this.running = running;
consoleInput.addKeyListener(new HistoryTextKeyListener(this)); }
} }
/** @param next the next message */ /** The class logger */
protected void appendConsoleOutput(final String next) { private static final Logger LOGGER = Logger
Display.getDefault().syncExec(new Runnable() { .getLogger(SWTConsoleView.class.getName());
@SuppressWarnings("synthetic-access") /** The console output text field */
@Override private final Text consoleOutput;
public void run() { /** The console input text field */
consoleOutput.append(System.lineSeparator() + next); private final Text consoleInput;
} /** The input. */
}); private PipedConsoleInput input;
} /** The forwarding runnable */
private ToSWTConsoleForwardRunnable forward;
@Override
protected void checkSubclass() { /** Create the composite.
// Disable the check that prevents subclassing of SWT components *
} * @param parent the prent composite
* @param style the composite style */
/* (non-Javadoc) public SWTConsoleView(final Composite parent, final int style) {
* @see fr.bigeon.gclc.swt.ConsoleDelayIO#getInput() */ super(parent, style);
@Override
public String getInput() { setLayout(new GridLayout(1, false));
return consoleInput.getText();
} consoleOutput = new Text(this, SWT.BORDER | SWT.READ_ONLY | SWT.WRAP |
SWT.V_SCROLL | SWT.MULTI);
/* (non-Javadoc) consoleOutput.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true,
* @see org.eclipse.swt.widgets.Composite#setFocus() */ 1, 1));
@Override consoleOutput.setRedraw(true);
public boolean setFocus() {
return consoleInput.setFocus(); consoleInput = new Text(this, SWT.BORDER);
} consoleInput.setLayoutData(
new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
/* (non-Javadoc) consoleInput.addKeyListener(new HistoryTextKeyListener(this));
* @see fr.bigeon.gclc.swt.ConsoleDelayIO#setInput(java.lang.String) */ }
@Override
public void setInput(final String input) { /** @param next the next message */
consoleInput.setText(input); protected void appendConsoleOutput(final String next) {
consoleInput.setSelection(input.length()); Display.getDefault().syncExec(new Runnable() {
} @SuppressWarnings("synthetic-access")
@Override
/** Set the input and output. public void run() {
* consoleOutput.append(System.lineSeparator() + next);
* @param manager the output to set }
* @param input the input */ });
public void setManager(final PipedConsoleOutput manager, }
final PipedConsoleInput input) {
this.input = input; @Override
if (forward != null) { protected void checkSubclass() {
forward.setRunning(false); // Disable the check that prevents subclassing of SWT components
} }
forward = new ToSWTConsoleForwardRunnable(manager);
final Thread th = new Thread(forward, "gclcToSWT"); //$NON-NLS-1$ /* (non-Javadoc)
th.start(); * @see net.bigeon.gclc.swt.ConsoleDelayIO#getInput() */
} @Override
public String getInput() {
/** @param string the text */ return consoleInput.getText();
public void setText(final String string) { }
consoleInput.setText(string);
} /* (non-Javadoc)
* @see org.eclipse.swt.widgets.Composite#setFocus() */
/** @Override
* public boolean setFocus() {
*/ return consoleInput.setFocus();
@Override }
public void validateInput() {
try { /* (non-Javadoc)
input.type(getInput()); * @see net.bigeon.gclc.swt.ConsoleDelayIO#setInput(java.lang.String) */
} catch (final IOException e) { @Override
LOGGER.log(Level.SEVERE, "Unable to input value to console", e); //$NON-NLS-1$ public void setInput(final String input) {
} consoleInput.setText(input);
} consoleInput.setSelection(input.length());
} }
/** Set the input and output.
*
* @param manager the output to set
* @param input the input */
public void setManager(final PipedConsoleOutput manager,
final PipedConsoleInput input) {
this.input = input;
if (forward != null) {
forward.setRunning(false);
}
forward = new ToSWTConsoleForwardRunnable(manager);
final Thread th = new Thread(forward, "gclcToSWT"); //$NON-NLS-1$
th.start();
}
/** @param string the text */
public void setText(final String string) {
consoleInput.setText(string);
}
/**
*
*/
@Override
public void validateInput() {
try {
input.type(getInput());
} catch (final IOException e) {
LOGGER.log(Level.SEVERE, "Unable to input value to console", e); //$NON-NLS-1$
}
}
}

77
gclc-swt/src/main/java/fr/bigeon/gclc/swt/package-info.java → gclc-swt/src/main/java/net/bigeon/gclc/swt/package-info.java
View File

@ -1,39 +1,38 @@
/* /** SWT components for a frontend of GCLC applications.
* GCLC swt, provide a swt window for console applications *
* Copyright (C) 2015-2017 E. Bigeon * @author Emmanuel Bigeon */
* mailto:emmanuel@bigeon.fr package net.bigeon.gclc.swt;
*
* This software is governed by the CeCILL license under French law and /*-
* abiding by the rules of distribution of free software. You can use, * #%L
* modify and/or redistribute the software under the terms of the CeCILL * GCLC swt
* license as circulated by CEA, CNRS and INRIA at the following URL * %%
* "http://www.cecill.info". * Copyright (C) 2015 - 2018 Bigeon
* * %%
* As a counterpart to the access to the source code and rights to copy, * This software is governed by the CeCILL license under French law and
* modify and redistribute granted by the license, users are provided only * abiding by the rules of distribution of free software. You can use,
* with a limited warranty and the software's author, the holder of the * modify and/ or redistribute the software under the terms of the CeCILL
* economic rights, and the successive licensors have only limited * license as circulated by CEA, CNRS and INRIA at the following URL
* liability. * "http://www.cecill.info".
* *
* In this respect, the user's attention is drawn to the risks associated * As a counterpart to the access to the source code and rights to copy,
* with loading, using, modifying and/or developing or reproducing the * modify and redistribute granted by the license, users are provided only
* software by the user in light of its specific status of free software, * with a limited warranty and the software's author, the holder of the
* that may mean that it is complicated to manipulate, and that also * economic rights, and the successive licensors have only limited
* therefore means that it is reserved for developers and experienced * liability.
* professionals having in-depth computer knowledge. Users are therefore *
* encouraged to load and test the software's suitability as regards their * In this respect, the user's attention is drawn to the risks associated
* requirements in conditions enabling the security of their systems and/or * with loading, using, modifying and/or developing or reproducing the
* data to be ensured and, more generally, to use and operate it in the * software by the user in light of its specific status of free software,
* same conditions as regards security. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* The fact that you are presently reading this means that you have had * professionals having in-depth computer knowledge. Users are therefore
* knowledge of the CeCILL license and that you accept its terms. * encouraged to load and test the software's suitability as regards their
*/ * requirements in conditions enabling the security of their systems and/or
/** * data to be ensured and, more generally, to use and operate it in the
* gclc-swt:fr.bigeon.gclc.swt.package-info.java * same conditions as regards security.
* Created on: Nov 18, 2017 *
*/ * The fact that you are presently reading this means that you have had
/** SWT components for a frontend of GCLC applications. * knowledge of the CeCILL license and that you accept its terms.
* * #L%
* @author Emmanuel Bigeon */ */
package fr.bigeon.gclc.swt;

252
gclc-swt/src/test/java/fr/bigeon/gclc/swt/HistoryTextKeyListenerTest.java → gclc-swt/src/test/java/net/bigeon/gclc/swt/HistoryTextKeyListenerTest.java
View File

@ -1,108 +1,144 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.HistoryTextKeyListenerTest.java * gclc-swt:net.bigeon.gclc.swt.HistoryTextKeyListenerTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import static org.junit.Assert.assertEquals; /*-
* #%L
import org.eclipse.swt.SWT; * GCLC swt
import org.junit.Test; * %%
* Copyright (C) 2015 - 2018 Bigeon
/** <p> * %%
* TODO * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel Bigeon */ * modify and/ or redistribute the software under the terms of the CeCILL
public class HistoryTextKeyListenerTest { * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
/** Test method for *
* {@link fr.bigeon.gclc.swt.HistoryTextKeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)}. */ * As a counterpart to the access to the source code and rights to copy,
@Test * modify and redistribute granted by the license, users are provided only
public final void testKeyPressedKeyEvent() { * with a limited warranty and the software's author, the holder of the
ConsoleDelayIO io = new ConsoleDelayIO() { * economic rights, and the successive licensors have only limited
private String input = ""; * liability.
*
@Override * In this respect, the user's attention is drawn to the risks associated
public void validateInput() { * with loading, using, modifying and/or developing or reproducing the
input = ""; * software by the user in light of its specific status of free software,
} * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
@Override * professionals having in-depth computer knowledge. Users are therefore
public void setInput(String input) { * encouraged to load and test the software's suitability as regards their
this.input = input; * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
@Override *
public String getInput() { * The fact that you are presently reading this means that you have had
return input; * knowledge of the CeCILL license and that you accept its terms.
} * #L%
}; */
HistoryTextKeyListener listener = new HistoryTextKeyListener(io); import static org.junit.Assert.assertEquals;
// no effects import org.eclipse.swt.SWT;
assertEquals("", io.getInput()); import org.junit.Test;
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("", io.getInput()); import net.bigeon.gclc.swt.ConsoleDelayIO;
listener.pressedKeyCode(SWT.ARROW_DOWN); import net.bigeon.gclc.swt.HistoryTextKeyListener;
assertEquals("", io.getInput());
listener.pressedKeyCode('\r'); /** <p>
assertEquals("", io.getInput()); * TODO
*
io.setInput("cmd arg"); * @author Emmanuel Bigeon */
listener.pressedKeyCode(SWT.ARROW_UP); public class HistoryTextKeyListenerTest {
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_DOWN); /** Test method for
assertEquals("cmd arg", io.getInput()); * {@link net.bigeon.gclc.swt.HistoryTextKeyListener#keyPressed(org.eclipse.swt.events.KeyEvent)}. */
listener.pressedKeyCode('\r'); @Test
assertEquals("", io.getInput()); public final void testKeyPressedKeyEvent() {
ConsoleDelayIO io = new ConsoleDelayIO() {
io.setInput("cmd arg2"); private String input = "";
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg", io.getInput()); @Override
listener.pressedKeyCode(SWT.ARROW_DOWN); public void validateInput() {
assertEquals("", io.getInput()); input = "";
io.setInput("cmd arg2"); }
listener.pressedKeyCode('\r');
assertEquals("", io.getInput()); @Override
listener.pressedKeyCode(SWT.ARROW_UP); public void setInput(String input) {
assertEquals("cmd arg2", io.getInput()); this.input = input;
listener.pressedKeyCode(SWT.ARROW_UP); }
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_UP); @Override
assertEquals("cmd arg", io.getInput()); public String getInput() {
listener.pressedKeyCode(SWT.ARROW_DOWN); return input;
assertEquals("cmd arg2", io.getInput()); }
} };
HistoryTextKeyListener listener = new HistoryTextKeyListener(io);
}
// no effects
assertEquals("", io.getInput());
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("", io.getInput());
listener.pressedKeyCode(SWT.ARROW_DOWN);
assertEquals("", io.getInput());
listener.pressedKeyCode('\r');
assertEquals("", io.getInput());
io.setInput("cmd arg");
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_DOWN);
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode('\r');
assertEquals("", io.getInput());
io.setInput("cmd arg2");
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_DOWN);
assertEquals("", io.getInput());
io.setInput("cmd arg2");
listener.pressedKeyCode('\r');
assertEquals("", io.getInput());
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg2", io.getInput());
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_UP);
assertEquals("cmd arg", io.getInput());
listener.pressedKeyCode(SWT.ARROW_DOWN);
assertEquals("cmd arg2", io.getInput());
}
}

701
gclc-swt/src/test/java/fr/bigeon/gclc/swt/SWTConsoleShellTest.java → gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleShellTest.java
View File

@ -1,333 +1,368 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.SWTConsoleShellTest.java * gclc-swt:net.bigeon.gclc.swt.SWTConsoleShellTest.java
* Created on: Jun 8, 2016 * Created on: Jun 8, 2016
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import static org.junit.Assert.assertFalse; /*-
import static org.junit.Assert.assertNotNull; * #%L
import static org.junit.Assert.assertTrue; * GCLC swt
import static org.junit.Assert.fail; * %%
* Copyright (C) 2015 - 2018 Bigeon
import java.io.IOException; * %%
* This software is governed by the CeCILL license under French law and
import org.eclipse.swt.widgets.Display; * abiding by the rules of distribution of free software. You can use,
import org.junit.Test; * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
import net.bigeon.gclc.ConsoleApplication; * "http://www.cecill.info".
import net.bigeon.gclc.command.Command; *
import net.bigeon.gclc.command.base.ExitCommand; * As a counterpart to the access to the source code and rights to copy,
import net.bigeon.gclc.exception.CommandRunException; * modify and redistribute granted by the license, users are provided only
import net.bigeon.gclc.exception.InvalidCommandName; * with a limited warranty and the software's author, the holder of the
import net.bigeon.gclc.manager.ConsoleInput; * economic rights, and the successive licensors have only limited
import net.bigeon.gclc.manager.ConsoleOutput; * liability.
*
/** * In this respect, the user's attention is drawn to the risks associated
* <p> * with loading, using, modifying and/or developing or reproducing the
* TODO * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @author Emmanuel Bigeon */ * therefore means that it is reserved for developers and experienced
@SuppressWarnings({"javadoc", "static-method", "nls", "deprecation"}) * professionals having in-depth computer knowledge. Users are therefore
public class SWTConsoleShellTest { * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
protected static final long TWO_SECONDS = 2000; * data to be ensured and, more generally, to use and operate it in the
private static final Display DISPLAY = Display.getDefault(); * same conditions as regards security.
*
@Test * The fact that you are presently reading this means that you have had
public void test() { * knowledge of the CeCILL license and that you accept its terms.
final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY); * #L%
final SWTConsole swtConsole = shell.getManager(); */
try { import static org.junit.Assert.assertFalse;
final ConsoleApplication appl = new ConsoleApplication(swtConsole, import static org.junit.Assert.assertNotNull;
swtConsole, "Hello", "See you"); import static org.junit.Assert.assertTrue;
appl.add(new ExitCommand("exit", appl)); import static org.junit.Assert.fail;
appl.add(new Command("long") {
import java.io.IOException;
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. import org.eclipse.swt.widgets.Display;
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, import org.junit.Test;
* java.lang.String[]) */
@Override import net.bigeon.gclc.ConsoleApplication;
public void execute(final ConsoleOutput out, import net.bigeon.gclc.command.Command;
final ConsoleInput in, import net.bigeon.gclc.command.base.ExitCommand;
final String... args) throws CommandRunException { import net.bigeon.gclc.exception.CommandRunException;
try { import net.bigeon.gclc.exception.InvalidCommandName;
Thread.sleep(TWO_SECONDS); import net.bigeon.gclc.manager.ConsoleInput;
} catch (final InterruptedException e) { import net.bigeon.gclc.manager.ConsoleOutput;
// TODO Auto-generated catch block import net.bigeon.gclc.swt.SWTConsole;
e.printStackTrace(); import net.bigeon.gclc.swt.SWTConsoleShell;
}
} /**
* <p>
@Override * TODO
public String tip() { *
return "a long running command"; * @author Emmanuel Bigeon */
} @SuppressWarnings({"javadoc", "static-method", "nls", "deprecation"})
public class SWTConsoleShellTest {
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usageDetail() */ protected static final long TWO_SECONDS = 2000;
@Override private static final Display DISPLAY = Display.getDefault();
protected String usageDetail() {
// TODO Auto-generated method stub @Test
// return null; public void test() {
throw new RuntimeException("Not implemented yet"); final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY);
} final SWTConsole swtConsole = shell.getManager();
}); try {
// shell.pack(); final ConsoleApplication appl = new ConsoleApplication(swtConsole,
shell.open(); swtConsole, "Hello", "See you");
final Thread applThread = new Thread(new Runnable() { appl.add(new ExitCommand("exit", appl));
appl.add(new Command("long") {
@Override
public void run() { /* (non-Javadoc)
appl.start(); * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
} * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
}); * java.lang.String[]) */
final Thread testThread = new Thread(new Runnable() { @Override
public void execute(final ConsoleOutput out,
@Override final ConsoleInput in,
public void run() { final String... args) throws CommandRunException {
try { try {
Thread.sleep(TWO_SECONDS); Thread.sleep(TWO_SECONDS);
} catch (final InterruptedException e) { } catch (final InterruptedException e) {
// TODO Auto-generated catch block // TODO Auto-generated catch block
e.printStackTrace(); e.printStackTrace();
} }
Display.getDefault().syncExec(new Runnable() { }
@Override
public void run() { @Override
swtConsole.setText("test"); //$NON-NLS-1$ public String tip() {
swtConsole.validateCommand(); return "a long running command";
} }
});
try { /* (non-Javadoc)
Thread.sleep(TWO_SECONDS); * @see fr.bigeon.gclc.command.Command#usageDetail() */
} catch (final InterruptedException e) { @Override
// TODO Auto-generated catch block protected String usageDetail() {
e.printStackTrace(); // TODO Auto-generated method stub
} // return null;
Display.getDefault().syncExec(new Runnable() { throw new RuntimeException("Not implemented yet");
@Override }
public void run() { });
shell.dispose(); // shell.pack();
} shell.open();
}); final Thread applThread = new Thread(new Runnable() {
}
}); @Override
applThread.start(); public void run() {
testThread.start(); appl.start();
while (!shell.isDisposed()) { }
if (!DISPLAY.readAndDispatch()) { });
DISPLAY.sleep(); final Thread testThread = new Thread(new Runnable() {
}
} @Override
// DISPLAY.dispose(); public void run() {
assertTrue(swtConsole.isClosed()); try {
Thread.sleep(TWO_SECONDS); Thread.sleep(TWO_SECONDS);
assertFalse(appl.isRunning()); } catch (final InterruptedException e) {
} catch (final InvalidCommandName e) { // TODO Auto-generated catch block
// TODO Auto-generated catch block e.printStackTrace();
e.printStackTrace(); }
} catch (final InterruptedException e) { Display.getDefault().syncExec(new Runnable() {
// TODO Auto-generated catch block @Override
e.printStackTrace(); public void run() {
} swtConsole.setText("test"); //$NON-NLS-1$
} swtConsole.validateCommand();
}
@Test });
public void testConsoleClose() { try {
final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY); Thread.sleep(TWO_SECONDS);
final SWTConsole swtConsole = shell.getManager(); } catch (final InterruptedException e) {
swtConsole.close(); // TODO Auto-generated catch block
swtConsole.setPrompt(":"); e.printStackTrace();
try { }
final ConsoleApplication appl = new ConsoleApplication(swtConsole, Display.getDefault().syncExec(new Runnable() {
swtConsole, "Hello", "See you"); @Override
appl.add(new ExitCommand("exit", appl)); public void run() {
appl.add(new Command("long") { shell.dispose();
/* (non-Javadoc) }
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. });
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, }
* java.lang.String[]) */ });
@Override applThread.start();
public void execute(final ConsoleOutput out, testThread.start();
final ConsoleInput in, while (!shell.isDisposed()) {
final String... args) throws CommandRunException { if (!DISPLAY.readAndDispatch()) {
try { DISPLAY.sleep();
Thread.sleep(TWO_SECONDS); }
} catch (final InterruptedException e) { }
// TODO Auto-generated catch block // DISPLAY.dispose();
e.printStackTrace(); assertTrue(swtConsole.isClosed());
} Thread.sleep(TWO_SECONDS);
} assertFalse(appl.isRunning());
} catch (final InvalidCommandName e) {
@Override // TODO Auto-generated catch block
public String tip() { e.printStackTrace();
return "a long running command"; } catch (final InterruptedException e) {
} // TODO Auto-generated catch block
e.printStackTrace();
/* (non-Javadoc) }
* @see fr.bigeon.gclc.command.Command#usageDetail() */ }
@Override
protected String usageDetail() { @Test
// TODO Auto-generated method stub public void testConsoleClose() {
// return null; final SWTConsoleShell shell = new SWTConsoleShell(DISPLAY);
throw new RuntimeException("Not implemented yet"); final SWTConsole swtConsole = shell.getManager();
} swtConsole.close();
}); swtConsole.setPrompt(":");
appl.add(new Command("test") { try {
/* (non-Javadoc) final ConsoleApplication appl = new ConsoleApplication(swtConsole,
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. swtConsole, "Hello", "See you");
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, appl.add(new ExitCommand("exit", appl));
* java.lang.String[]) */ appl.add(new Command("long") {
@Override /* (non-Javadoc)
public void execute(final ConsoleOutput out, * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
final ConsoleInput in, * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
final String... args) throws CommandRunException { * java.lang.String[]) */
try { @Override
swtConsole.prompt("Test"); public void execute(final ConsoleOutput out,
} catch (final IOException e) { final ConsoleInput in,
throw new CommandRunException("No input", e); final String... args) throws CommandRunException {
} try {
} Thread.sleep(TWO_SECONDS);
} catch (final InterruptedException e) {
@Override // TODO Auto-generated catch block
public String tip() { e.printStackTrace();
return "a prompting running command"; }
} }
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.command.Command#usageDetail() */ public String tip() {
@Override return "a long running command";
protected String usageDetail() { }
// TODO Auto-generated method stub
// return null; /* (non-Javadoc)
throw new RuntimeException("Not implemented yet"); * @see fr.bigeon.gclc.command.Command#usageDetail() */
} @Override
}); protected String usageDetail() {
// shell.pack(); // TODO Auto-generated method stub
shell.open(); // return null;
final Thread applThread = new Thread(new Runnable() { throw new RuntimeException("Not implemented yet");
}
@Override });
public void run() { appl.add(new Command("test") {
appl.start(); /* (non-Javadoc)
} * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
}); * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
final Thread testThread = new Thread(new Runnable() { * java.lang.String[]) */
@Override
@Override public void execute(final ConsoleOutput out,
public void run() { final ConsoleInput in,
try { final String... args) throws CommandRunException {
Thread.sleep(TWO_SECONDS); try {
} catch (final InterruptedException e) { swtConsole.prompt("Test");
// TODO Auto-generated catch block } catch (final IOException e) {
e.printStackTrace(); throw new CommandRunException("No input", e);
} }
Display.getDefault().syncExec(new Runnable() { }
@Override
public void run() { @Override
swtConsole.setText("test"); //$NON-NLS-1$ public String tip() {
swtConsole.validateCommand(); return "a prompting running command";
} }
});
Display.getDefault().syncExec(new Runnable() { /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.command.Command#usageDetail() */
public void run() { @Override
swtConsole.setText("ok"); //$NON-NLS-1$ protected String usageDetail() {
} // TODO Auto-generated method stub
}); // return null;
swtConsole.validateCommand(); throw new RuntimeException("Not implemented yet");
Display.getDefault().syncExec(new Runnable() { }
@Override });
public void run() { // shell.pack();
swtConsole.setText("long"); //$NON-NLS-1$ shell.open();
} final Thread applThread = new Thread(new Runnable() {
});
swtConsole.validateCommand(); @Override
Display.getDefault().syncExec(new Runnable() { public void run() {
@Override appl.start();
public void run() { }
swtConsole.setText("test"); //$NON-NLS-1$ });
} final Thread testThread = new Thread(new Runnable() {
});
swtConsole.validateCommand(); @Override
Display.getDefault().syncExec(new Runnable() { public void run() {
@Override try {
public void run() { Thread.sleep(TWO_SECONDS);
swtConsole.setText("test"); //$NON-NLS-1$ } catch (final InterruptedException e) {
} // TODO Auto-generated catch block
}); e.printStackTrace();
swtConsole.validateCommand(); }
try { Display.getDefault().syncExec(new Runnable() {
Thread.sleep(TWO_SECONDS); @Override
} catch (final InterruptedException e) { public void run() {
// TODO Auto-generated catch block swtConsole.setText("test"); //$NON-NLS-1$
e.printStackTrace(); swtConsole.validateCommand();
} }
Display.getDefault().syncExec(new Runnable() { });
@Override Display.getDefault().syncExec(new Runnable() {
public void run() { @Override
shell.dispose(); public void run() {
} swtConsole.setText("ok"); //$NON-NLS-1$
}); }
});
} swtConsole.validateCommand();
}); Display.getDefault().syncExec(new Runnable() {
applThread.start(); @Override
testThread.start(); public void run() {
while (!shell.isDisposed()) { swtConsole.setText("long"); //$NON-NLS-1$
if (!DISPLAY.readAndDispatch()) { }
DISPLAY.sleep(); });
} swtConsole.validateCommand();
} Display.getDefault().syncExec(new Runnable() {
swtConsole.setPrompt(">"); @Override
try { public void run() {
swtConsole.prompt(); swtConsole.setText("test"); //$NON-NLS-1$
fail("Prompting when closed should fail!"); }
} catch (final IOException e) { });
assertNotNull(e); swtConsole.validateCommand();
} Display.getDefault().syncExec(new Runnable() {
// DISPLAY.dispose(); @Override
assertTrue(swtConsole.isClosed()); public void run() {
Thread.sleep(TWO_SECONDS); swtConsole.setText("test"); //$NON-NLS-1$
assertFalse(appl.isRunning()); }
} catch (final InvalidCommandName e) { });
// TODO Auto-generated catch block swtConsole.validateCommand();
e.printStackTrace(); try {
} catch (final InterruptedException e) { Thread.sleep(TWO_SECONDS);
// TODO Auto-generated catch block } catch (final InterruptedException e) {
e.printStackTrace(); // TODO Auto-generated catch block
} e.printStackTrace();
} }
} Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
shell.dispose();
}
});
}
});
applThread.start();
testThread.start();
while (!shell.isDisposed()) {
if (!DISPLAY.readAndDispatch()) {
DISPLAY.sleep();
}
}
swtConsole.setPrompt(">");
try {
swtConsole.prompt();
fail("Prompting when closed should fail!");
} catch (final IOException e) {
assertNotNull(e);
}
// DISPLAY.dispose();
assertTrue(swtConsole.isClosed());
Thread.sleep(TWO_SECONDS);
assertFalse(appl.isRunning());
} catch (final InvalidCommandName e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (final InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

372
gclc-swt/src/test/java/fr/bigeon/gclc/swt/SWTConsoleViewTest.java → gclc-swt/src/test/java/net/bigeon/gclc/swt/SWTConsoleViewTest.java
View File

@ -1,169 +1,203 @@
/* /*
* GCLC swt, provide a swt window for console applications * GCLC swt, provide a swt window for console applications
* Copyright (C) 2015-2017 E. Bigeon * Copyright (C) 2015-2017 E. Bigeon
* mailto:emmanuel@bigeon.fr * mailto:emmanuel@bigeon.fr
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-swt:fr.bigeon.gclc.swt.SWTConsoleShellTest.java * gclc-swt:net.bigeon.gclc.swt.SWTConsoleShellTest.java
* Created on: Jun 8, 2016 * Created on: Jun 8, 2016
*/ */
package fr.bigeon.gclc.swt; package net.bigeon.gclc.swt;
import static org.junit.Assert.assertNull; /*-
* #%L
import java.io.IOException; * GCLC swt
* %%
import org.eclipse.swt.SWT; * Copyright (C) 2015 - 2018 Bigeon
import org.eclipse.swt.widgets.Display; * %%
import org.eclipse.swt.widgets.Shell; * This software is governed by the CeCILL license under French law and
import org.junit.Test; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
import net.bigeon.gclc.ConsoleApplication; * license as circulated by CEA, CNRS and INRIA at the following URL
import net.bigeon.gclc.command.Command; * "http://www.cecill.info".
import net.bigeon.gclc.command.base.ExitCommand; *
import net.bigeon.gclc.exception.CommandRunException; * As a counterpart to the access to the source code and rights to copy,
import net.bigeon.gclc.exception.InvalidCommandName; * modify and redistribute granted by the license, users are provided only
import net.bigeon.gclc.manager.ConsoleInput; * with a limited warranty and the software's author, the holder of the
import net.bigeon.gclc.manager.ConsoleOutput; * economic rights, and the successive licensors have only limited
import net.bigeon.gclc.utils.PipedConsoleInput; * liability.
import net.bigeon.gclc.utils.PipedConsoleOutput; *
* In this respect, the user's attention is drawn to the risks associated
/** <p> * with loading, using, modifying and/or developing or reproducing the
* TODO * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @author Emmanuel Bigeon */ * therefore means that it is reserved for developers and experienced
@SuppressWarnings({"javadoc", "static-method", "nls", "deprecation"}) * professionals having in-depth computer knowledge. Users are therefore
public class SWTConsoleViewTest { * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
protected static final long TWO_SECONDS = 2000; * data to be ensured and, more generally, to use and operate it in the
private static final Display DISPLAY = Display.getDefault(); * same conditions as regards security.
*
@Test * The fact that you are presently reading this means that you have had
public void test() { * knowledge of the CeCILL license and that you accept its terms.
final Shell shell = new Shell(DISPLAY); * #L%
final SWTConsoleView swtConsole = new SWTConsoleView(shell, SWT.NONE); */
try (PipedConsoleOutput manager = new PipedConsoleOutput(); import static org.junit.Assert.assertNull;
PipedConsoleInput input = new PipedConsoleInput(System.out)) {
swtConsole.setManager(manager, input); import java.io.IOException;
} catch (final IOException e2) {
assertNull(e2); import org.eclipse.swt.SWT;
} import org.eclipse.swt.widgets.Display;
try (PipedConsoleOutput manager = new PipedConsoleOutput(); import org.eclipse.swt.widgets.Shell;
PipedConsoleInput input = new PipedConsoleInput(System.out)) { import org.junit.Test;
swtConsole.setManager(manager, input);
final ConsoleApplication appl = new ConsoleApplication(manager, import net.bigeon.gclc.ConsoleApplication;
input, import net.bigeon.gclc.command.Command;
"Hello", "See you"); import net.bigeon.gclc.command.base.ExitCommand;
appl.add(new ExitCommand("exit", appl)); import net.bigeon.gclc.exception.CommandRunException;
appl.add(new Command("long") { import net.bigeon.gclc.exception.InvalidCommandName;
import net.bigeon.gclc.manager.ConsoleInput;
/* (non-Javadoc) import net.bigeon.gclc.manager.ConsoleOutput;
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, java.lang.String[]) import net.bigeon.gclc.swt.SWTConsoleView;
*/ import net.bigeon.gclc.utils.PipedConsoleInput;
@Override import net.bigeon.gclc.utils.PipedConsoleOutput;
public void execute(final ConsoleOutput out, final ConsoleInput in,
final String... args) throws CommandRunException { /** <p>
try { * TODO
Thread.sleep(TWO_SECONDS); *
} catch (final InterruptedException e) { * @author Emmanuel Bigeon */
// TODO Auto-generated catch block @SuppressWarnings({"javadoc", "static-method", "nls", "deprecation"})
e.printStackTrace(); public class SWTConsoleViewTest {
}
} protected static final long TWO_SECONDS = 2000;
private static final Display DISPLAY = Display.getDefault();
@Override
public String tip() { @Test
return "a long running command"; public void test() {
} final Shell shell = new Shell(DISPLAY);
final SWTConsoleView swtConsole = new SWTConsoleView(shell, SWT.NONE);
/* (non-Javadoc) try (PipedConsoleOutput manager = new PipedConsoleOutput();
* @see fr.bigeon.gclc.command.Command#usageDetail() */ PipedConsoleInput input = new PipedConsoleInput(System.out)) {
@Override swtConsole.setManager(manager, input);
protected String usageDetail() { } catch (final IOException e2) {
// TODO Auto-generated method stub assertNull(e2);
// return null; }
throw new RuntimeException("Not implemented yet"); try (PipedConsoleOutput manager = new PipedConsoleOutput();
} PipedConsoleInput input = new PipedConsoleInput(System.out)) {
}); swtConsole.setManager(manager, input);
// shell.pack(); final ConsoleApplication appl = new ConsoleApplication(manager,
shell.open(); input,
final Thread applThread = new Thread(new Runnable() { "Hello", "See you");
appl.add(new ExitCommand("exit", appl));
@Override appl.add(new Command("long") {
public void run() {
appl.start(); /* (non-Javadoc)
} * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, java.lang.String[])
}); */
final Thread testThread = new Thread(new Runnable() { @Override
public void execute(final ConsoleOutput out, final ConsoleInput in,
@Override final String... args) throws CommandRunException {
public void run() { try {
try { Thread.sleep(TWO_SECONDS);
Thread.sleep(TWO_SECONDS); } catch (final InterruptedException e) {
} catch (final InterruptedException e) { // TODO Auto-generated catch block
// TODO Auto-generated catch block e.printStackTrace();
e.printStackTrace(); }
} }
Display.getDefault().syncExec(new Runnable() {
@Override @Override
public void run() { public String tip() {
swtConsole.setText("test"); //$NON-NLS-1$ return "a long running command";
swtConsole.validateInput(); }
}
}); /* (non-Javadoc)
try { * @see fr.bigeon.gclc.command.Command#usageDetail() */
Thread.sleep(TWO_SECONDS); @Override
} catch (final InterruptedException e) { protected String usageDetail() {
// TODO Auto-generated catch block // TODO Auto-generated method stub
e.printStackTrace(); // return null;
} throw new RuntimeException("Not implemented yet");
Display.getDefault().syncExec(new Runnable() { }
@Override });
public void run() { // shell.pack();
shell.dispose(); shell.open();
} final Thread applThread = new Thread(new Runnable() {
});
} @Override
}); public void run() {
applThread.start(); appl.start();
testThread.start(); }
while (!shell.isDisposed()) { });
if (!DISPLAY.readAndDispatch()) { final Thread testThread = new Thread(new Runnable() {
DISPLAY.sleep();
} @Override
} public void run() {
} catch (final InvalidCommandName e) { try {
// TODO Auto-generated catch block Thread.sleep(TWO_SECONDS);
e.printStackTrace(); } catch (final InterruptedException e) {
} catch (final IOException e1) { // TODO Auto-generated catch block
// TODO Auto-generated catch block e.printStackTrace();
e1.printStackTrace(); }
} Display.getDefault().syncExec(new Runnable() {
} @Override
} public void run() {
swtConsole.setText("test"); //$NON-NLS-1$
swtConsole.validateInput();
}
});
try {
Thread.sleep(TWO_SECONDS);
} catch (final InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
shell.dispose();
}
});
}
});
applThread.start();
testThread.start();
while (!shell.isDisposed()) {
if (!DISPLAY.readAndDispatch()) {
DISPLAY.sleep();
}
}
} catch (final InvalidCommandName e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (final IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}