All Classes Interface Summary Class Summary Exception Summary
| Class |
Description |
| AbstractCurve |
A curve made up of a concatenation of cubic bezier curves and straight lines,
hereafter globally denoted as "segments".
|
| AbstractCurveFormatter |
Format an AbstractCurve, or any subclass of it, to the eepic format.
|
| AbstractCurveFormatter |
Format an AbstractCurve, or any subclass of it, to the LaTeX-picture format.
|
| AbstractCurveFormatter |
Format an AbstractCurve, or any subclass of it, using PsTricks macros.
|
| AbstractCustomizer |
An abstract superclass that alleviates the burden of creating a customizer panel,
by providing a common set of behaviours where storing/retrieving value
to/from a Properties object (or any storage class) is concerned.
|
| AbstractElement |
An abstract class that can serve as the basis class for elements of a Drawing.
|
| AbstractMouseTransform |
This implementation allows subclassers to modify a clone
of the target Element, then to update the original Element when the operation is completed.
|
| AbstractMouseTransformFactory |
Provide a skeletal implementation of the MouseTransformFactory interface.
|
| AbstractRegularExpression |
This is the abstract superclass for all regular expressions that may help building a RegExp-based parser.
|
| AbstractSelectionHandler |
Provides some basic implementation of the SelectionHandler interface.
|
| AbstractView |
Abstract implementation that provide some basic common behaviours for View's.
|
| ActionDispatcher |
Allow PEAction's to know upon which target they must act.
|
| ActionFactory |
Allows an Element, in interaction with a PopupMenuFactory, to produce Action's that make sense
only with this Element.
|
| ActionLocalizer |
This interface, once properly implemented, may be used as a parameter for a PEAction, and can feed it
with localized properties (e.g.
|
| ActionRegistry |
A registry that retains all JPicEdt's actions in a map,
supplies them on-demand through a String key, and knows how to update actions state using
the currently installed MDIManager.
|
| AlternateExpression |
A regular expression that mimics the "x|y" RegExp syntax.
|
| Arrow |
A class implementing the arrow attribute.
|
| BasicEditPointConstraint |
Default implementation of EditPointConstraint.
|
| BeanShell |
Wrapper for the BSH interpreter console + some useful static methods for running scripts from inside JPicEdt.
|
| BeginPictureExpression |
LaTeX or eepic :
\begin{picture}(w,h)
\begin{picture}(w,h)(x,y)
|
| BeginPsPictureExpression |
\begin{pspicture}(x0,y0)(x1,y1) -> defines a box with BL=(x0,y0) and TR=(x1,y1)
\begin{pspicture}*(x0,y0)(x1,y1) -> clipped
\begin{pspicture}[baseline](x0,y0)(x1,y1) -> changes baseline (see pstricks's doc p.41)
\begin{pspicture}[](x0,y0)(x1,y1) -> baseline passes across the origine
And the same commands with \pspicture (that is, TeX-like).
|
| BranchElement |
An abstract class for Element's that allow children.
|
| CommentExpression |
Parse comment strings.
|
| CompositeView |
a CompositeView is a graphic representation of a BranchElement
|
| ContentType |
Specifies a content-type (aka mime-type) for a Drawing document created by an editor-kit.
|
| Context |
A class that stores context information about the parsing process, like : current line
number, current parsed substring, block markers, stack for markers...
|
| CursorFactory |
A factory for custom cursors.
|
| CustomizerDialog |
A dialog box that lays out an array of AbstractCustomizer's inside a JPanel or
a JTabbedPane, depending on the number of customizers fed to the constructor.
|
| CustomizerFactory |
Tags Element's able to produce an AbstractCustomizer suited for editing its geometry.
|
| DebugFocusManager |
A subclass of Swing's DefaultFocusManager that aims at helping us debug FocusEvent related bugs
|
| DebugRepaintManager |
A RepaintManager that may used for debugging purpose
|
| DecimalNumberField |
A JtextField that accept only DecimalNumbers
|
| DefaultActionDispatcher |
An implementation of the ActionDispatcher interface that's suited for non-shared PEAction's
(ie actions which are permanently "attached" to a given PECanvas).
|
| DefaultContentType |
Default implementation of the ContentType interface suited for the JPIC-XML language.
|
| DefaultHighlighterFactory |
This is the default factory used to create a Highlighter for a given Element.
|
| DefaultLeafElement |
This is a default implementation of AbstractElement targetting leaf Element's, i.e.
|
| DefaultParser |
Default implementation of the Parser interface.
|
| DefaultPointIndexIterator |
Default implementation of the PointIndexIterator interface, which simply iterates in ascending order over all control points.
|
| DefaultSelectionHandler |
Stores references to selected Element's.
|
| DefaultViewFactory |
This is the default factory used to create a View for a given Element ; should be used when
one wants to render all Element's attributes ; otherwise subclass with your own ViewFactory
and override :
createView : simply return your own View for some or all Element's (then call super.createView)
factory methods, e.g.
|
| DialogAbout |
"About..." dialog box ; displays various informations such as copyright, author(s),...
|
| DirectoriesCustomizer |
A panel for editing default directories, e.g.
|
| DockableAttributesCustomizer |
A dockable customizer for attributes (ie PicAttributesSet).
|
| DockableEditorKitToolBar |
A toolbar that offers various tools for drawing, editing, selecting...
|
| Drawing |
An extensible array used to store Elements
|
| DrawingEvent |
Interface for notifications of changes in a Drawing.
|
| DrawingEvent.EventType |
enumeration for DrawingEvent types
|
| DrawingListener |
Interface for an observer to receive notifications of changes made to a Drawing
|
| DrawToolFactory |
A factory that produces mouse-tools for drawing (ie adding) graphical element's to a canvas.
|
| EditElementMouseTransformFactory |
A factory that produces MouseTransform's that may be plugged into the SelectionTool mouse tool.
|
| EditorKit |
A pluggable EditorKit for a PECanvas, that mainly provides mouse-tool management,
e.g.
|
| EditorKit.ActivateSnapAction |
Toggles grid-snap activation
|
| EditorKit.CopyAction |
Copy target's content to clipboard
|
| EditorKit.CutAction |
Cut target's content to clipboard
|
| EditorKit.DeleteAction |
Delete the current selection
|
| EditorKit.EditBoundingBoxAction |
edit Drawing's bounding box
|
| EditorKit.EditDispositionAction |
Bring one or more selected objets to back, to front, forward or backward.
|
| EditorKit.EditGeometryAction |
Open a dialog that allows the user to edit the geometry of the currently selected element
from a dialog box.
|
| EditorKit.GroupAction |
Group all selected objects into a new PicGroup.
|
| EditorKit.JoinCurvesAction |
Join all selected objects of type PicMultiCurveConvertable into a new PicMultiCurve.
|
| EditorKit.PasteAction |
Paste the content of the given ClipBoard into the target canvas
|
| EditorKit.SelectAllAction |
selects all objects in the current active internal frame
|
| EditorKit.SelectMouseToolAction |
Sets the current mouse-tool for the editor-kit.
|
| EditorKit.ShowGridAction |
Toggles grid's visible state
|
| EditorKit.ToggleEditPointsModeAction |
Toggles the EditorKit's edit-points-mode b/w LOCAL_MODE and GLOBAL_MODE.
|
| EditorKit.UngroupAction |
Ungroup the current selection if this makes sense.
|
| EditorKit.ZoomInAction |
zoom in
|
| EditorKit.ZoomOutAction |
zoom out
|
| EditorKitEvent |
A class that allows an EditorKit's mousetool to send high-level mouse-events, i.e.
|
| EditorKitEvent.EventType |
typesafe enumeration of allowed event types
|
| EditorKitListener |
Interface for an observer to receive notifications of changes produced by an EditorKit
|
| EditPointConstraint |
So far, this is just a tagging interface for constraints passed to Element.setPoint() methods.
|
| EditPointConstraintCollator |
Collates several constraints together, ensuring there is no duplicate constraints.
|
| EditPointMouseTransformFactory |
A factory that produces MouseTransform's that may be plugged into the SelectionTool mouse-tool.
|
| EepicConstants |
Constants useful for Eepic formatters
|
| EepicContentType |
Specifies content-type for Drawing's created by editor-kits.
|
| EepicCustomizer |
a panel for Epic/Eepic preferences editing
|
| EepicDrawlineCommand |
Eepic open polygon, possibly dashed :
\\drawline[stretch](x1,y1)...(xN,yN)
|
| EepicFormatter |
Formatter for the eepic package.
|
| EepicLineThicknessExpression |
\thinlines or \thicklines or (eepic) \Thicklines
|
| EepicParser |
Grammar tree for the epic/eepic parser.
|
| EepicPathCommand |
Eepic "fast" (solid) polygon : \\path(x1,y1)...(xN,yN)
|
| EepicViewFactory |
A factory to create a View for a given Element when the content type for the model is Eepic.
|
| Element |
This interface specifies the general contract for models of graphic elements that may be added to a Drawing.
|
| EnclosingExpression |
An expression that can encompass a sub-expression it encloses with markers, e.g.
|
| EndPictureExpression |
\end{picture}
|
| EndPsPictureExpression |
\end{pspicture} and/or \endpspicture.
A REParserException.EndOfPicture is thrown when this expression gets successfully parsed, which
give a chance to the receiver to end up the parsing process here.
|
| ExpressionConstants |
Constants used by subclasses of AbstractRegularExpression.
|
| FontSelector |
A font chooser widget (adapted from jEdit source code)
|
| Formatter |
An interface that specifies shared formatting behaviours for Element's.
|
| FormatterFactory |
|
| Fragments |
Fragments menu management
|
| GeneralCustomizer |
a panel for general preferences editing (LAF, language,...)
|
| Grid |
A grid for PECanvas, defined in model-coordinate (natural unit = 1mm)
Provides the ability to find a nearest-neighbour point on the grid, given a point in model-coordinate,
using current snap-step value
Offers several paint schemes (grid step)
|
| GridZoomCustomizer |
Grid and zoom preferences editing.
|
| HelpMessageEvent |
A class that allows an EditorKit to post help-messages (or tooltips) that make sense with the current
operation being performed.
|
| HelpMessageListener |
Interface for an observer to receive help messages posted by an EditorKit
|
| Highlighter |
a view dedicated to painting an Element's highlighter, e.g.
|
| HighlighterFactory |
A factory to create a Highlighter for a given Element.
|
| HistoryModel |
A history list.
|
| HistoryTextField |
Text field with an arrow-key accessable history.
|
| HitInfo |
A HitInfo encapsulates information related to a mouse click that occured on a particular area of an Element.
|
| HitInfo.Composite |
Represent a particular type of Hit that occured on a child of a branch-element, when
one whants to specify both the element and its child.
|
| HitInfo.EnvelopeStroke |
Deprecated.
|
| HitInfo.HighlighterStroke |
Represent a Hit that occured on the stroke of a highlighter (eg tangents of a PicSmoothPolygon).
|
| HitInfo.Interior |
Represent a Hit that occured on the interior of a Element
|
| HitInfo.Point |
Represent a Hit that occured on one or several Element's control-points, the latter case
occuring necessarily iff some control-points are identical.
|
| HitInfo.Stroke |
Represent a Hit that occured on an Element.
|
| HitInfo.Text |
Represent a Hit that occured on some interior area of a TextEditable.
|
| HtmlViewer |
A frame for displaying HTML content (e.g.
|
| IncrementableTextField |
A JComponent that lump together a JSpinner (with a +/- arrow field that allows the user to increment/decrement)
and prefix/postfix labels.
|
| InstanciationExpression |
An expression that can instanciate a new Element by cloning the given graphic element when it finds a given
litteral tag, then add it to the current PicGroup in the pool.
|
| InternalFrameMDIManager |
An MDI Manager implementation for "childframe" mode (ie using JInternalFrame's).
|
| JFrameMDIManager |
An MDI Manager implementation for JFrame's
|
| JPICCircleFormatter |
JPIC-XML formatter for PicCircleFrom3Points objects.
|
| JPICConstants |
Useful constants used across the jpicedt.graphic.io.formatter package
|
| JPicEdt |
Application main class (this class is not shipped in the jpicedt library)
|
| JPicEdt.AboutAction |
Opens the "about..." dialog box
|
| JPicEdt.ContentTypeAction |
Set the content-type of the currently active board
|
| JPicEdt.ExitAction |
Exit jPicEdt
|
| JPicEdt.FileCloseAction |
Close the active board
|
| JPicEdt.FileNewAction |
Create a new board from scratch, performing operation in a separate thread.
|
| JPicEdt.FileOpenAction |
Open a board from disk, performing I/O operations in a separate thread
|
| JPicEdt.FileReloadAction |
Reload the active board from disk, performing I/O operation in a separate thread.
|
| JPicEdt.FileSaveAction |
save a frame content to disk, performing I/O operations in a separate thread
|
| JPicEdt.FileSaveAllAction |
Save all open boards to disk.
|
| JPicEdt.FileSaveAsAction |
Save the active board to disk with a new file name, performing I/O operations in a separate thread
|
| JPicEdt.FragmentInsertAction |
Insert a fragment into the active board, performing I/O operation in a separate thread.
|
| JPicEdt.FragmentSaveAction |
save the selection content of the active board to disk as a "fragment"
|
| JPicEdt.MemoryMonitorAction |
Display memory information
|
| JPicEdt.OpenBSHConsoleAction |
Open a BeanShell console
|
| JPicEdt.PageFormatAction |
Set the format of the currently active board
|
| JPicEdt.PreferencesAction |
Open the "preferences" dialog box
|
| JPicEdt.RedoAction |
Redoes last action
|
| JPicEdt.RedrawAction |
Redraws (aka repaint()) active internal frame
|
| JPicEdt.RunExternalCommandAction |
run an external process
|
| JPicEdt.ShowErrorLogAction |
open a frame containing the error.log file
|
| JPicEdt.ShowHelpAction |
open a frame containing the help (HTML formatted) page.
|
| JPicEdt.ShowLicenseAction |
open a frame containing the (HTML formatted) GPL license page.
|
| JPicEdt.ToggleAttributesPanelAction |
Toggle the visibility of the attributes editor
|
| JPicEdt.ToggleToolkitPanelAction |
Toggle the visibility of the toolkit panel
|
| JPicEdt.UndoAction |
Undoes last action
|
| JPicEdt.ViewLaTeXFileAction |
Display the LaTeX content of the active board in a Dialog Box
|
| JPicEdt.WindowCascadeAction |
Cascades internal frames
|
| JPicEdt.WindowTileHorAction |
Tiles internal frames horizontally
|
| JPicEdt.WindowTileVertAction |
Tiles internal frames vertically
|
| JPICEllipseFormatter |
JPIC-XML formatter for PicEllipsegram objects.
|
| JPICFormatter |
a FormatterFactory that produces formatters for the JPIC-XML native format
|
| JPICGroupFormatter |
A JPIC-XML formatter for PicGroup objects.
Syntax : ...
|
| JPICMultiCurveFormatter |
JPIC-XML formatter for PicMultiCurve objects.
|
| JPICParallelogramFormatter |
JPIC-XML formatter for PicParallelogram objects.
|
| JPICParser |
An implementation of the Parser interface dedicated to parsing JPIC-XML files.
|
| JPICPsCurveFormatter |
JPIC-XML formatter for PicPsCurve objects, aka PsTricks \\pscurve macro.
|
| JPICSmoothPolygonFormatter |
JPIC-XML formatter for PicSmoothPolygon objects.
|
| JPICTextFormatter |
A formatter for PicText objects in the JPIC-XML format :
text here !
where :
refpoint = B|b|t for vertical and l|r for horizontal (B = baseline)
rotation = any angle in degree or U,L,D,R,N,W,S or E.
|
| JPICXmlHandler |
Content-handler and error-handler for the JPICParser class.
|
| KeyEventWorkaround |
|
| LAFManager |
LAF management : maintains a list of installed LAF, and handles LAF loading.
|
| LaTeXBox |
Parses LaTeX boxes, i.e.
|
| LaTeXCircle |
Parses LaTeX circles, i.e.
|
| LatexConstants |
"emulated latex" parameters : these parameters get used by LatexFormatter, LatexParser
and LatexViewFactory.
|
| LatexContentType |
Specifies content-type for Drawing's created by editor-kits.
|
| LatexCustomizer |
a panel for LaTeX preferences editing (emulation parameters,...)
|
| LatexFormatter |
LaTeX formater
|
| LaTeXInstanciationExpression |
instanciates a new Element by cloning the given object, when it finds the given tag,
then adds it to the current PicGroup ; makes use of the PicAttributeSet associated with
the ATTRIBUTES key in LaTeXParser.
|
| LaTeXLine |
Parses LaTeX lines, with or without arrows, i.e.
|
| LaTeXOval |
Parses LaTeX \\oval command.
|
| LaTeXParser |
Grammar rules for the LaTeX's picture environment parser
|
| LaTeXPicPointExpression |
an expression that parses "(x,y)" string (LaTeX-like PicPoint)
and gives the corresponding numerical values to the point number "ptNumber" of the current Element
using its setPoint(), using the given constraint.
|
| LaTeXPutExpression |
\\put(x,y){argument}
|
| LatexViewFactory |
Creates a View for a given Element when the underlying content type is the LaTeX-picture environment.
|
| LineThicknessExpression |
Legal syntax :
\\linethickness{0.4pt}
\\linethickness{0.4mm}
\\linethickness{0.4cm}
\\linethickness{0.4} // default to mm
note : 1pt = 1/72.27 inch = 0.3515 mm cf.
|
| LiteralExpression |
An expression specified by a String to be exactly matched at the current cursor position.
|
| Localizer |
Localizer for all classes of the jpicedt's tree.
It uses "lang/i18n_xx_yy.properties" resource file, where xx_yy is the Locale.
|
| Log |
Utility class for printing out debugging messages.
|
| MDIManager |
An abstract class that serves as the superclass for jPicEdt's Multiple Document Interface desktop managers.
|
| MDIManager.MDIComponent |
A common interface for UI components being hosted by this MDIManager.
|
| MiscUtilities |
A collection of static utilities methods.
|
| ModalInternalFrame |
Re-implementation of JDialog using JInternalFrame's.
|
| MotifLAFCellRenderer |
A customized cell-renderer for the Motif LAF (turns selected item background to white)
|
| MouseTool |
An implementation of PEMouseInputListener that factors common behaviour for EditorKit's mouse tools,
and implements KeyListener so that mouse-tools can also listen to key events (e.g.
|
| MouseTransform |
an interface that specifies behaviours shared by mouse-driven object-editing actions, especially
when driven by SelectionTool.
|
| MouseTransformFactory |
A factory that produces MouseTransform's to be used by the SelectionTool mouse-tool.
|
| MoveTool |
A MouseTool used to translate a target Element by a given vector.
|
| NotParsableExpression |
Any string (but w/o line-feeds !)
|
| NumericalExpression |
An expression containing only digits, possibly preceded by whitespaces ;
a post-delimiters can be specified, as well as the number's type (int or double) and its sign
|
| OptionalExpression |
an expression that represents a pattern repeating at most once
|
| PageFormat |
|
| PageFormat.Customizer |
a dialog box used to change a PageFormat
|
| Parser |
This is the interface from which every parser passed as a parameter to "PECanvas.read()" (or similar
methods from related classes) must inherit.
|
| ParserEvent |
An event that gets sent as an argument of the "action" method during an interpret operation
|
| ParserException |
Placeholder for the Exception class ; should serve as the base-class for any Exception related
to parsing processes, and may be used as an Exception wrapper as well, e.g.
|
| ParserException.UnrecognizedFileFormat |
May signal that the content being currently parsed does not correspond to
any recognized/supported format
|
| PEAction |
An abstract subclass of Swing's AbstractAction that can (but may as well not)
be shared across multiple PECanvas.
|
| PEActionLocalizer |
A class that can feed PEAction's with localized properties (e.g.
|
| PECanvas |
This is a JComponent on which graphic elements are drawn.
|
| PEDrawingBoard |
A drawing board based on jpicedt.graphic.PECanvas, with an embeded scrollpane, and
some I/O facilities (saving and loading) which PECanvas doesn't have.
There are two accessors two retrieve the embedded canvas and scrollpane.
|
| PEEventMulticaster |
|
| PEFileChooser |
A factory than produces and caches frequently accessed JFileChooser's.
|
| PEFileFilter |
a concrete implementation of FileFilter for LaTeX and rel.
|
| PEMenu |
This is a subclass of JMenu that allows to add Swing Action's using
the ACCELERATOR_KEY property (contrary to the JMenu implementation).
|
| PEMenuBar |
The main menu bar.
|
| PEMouseEvent |
This is an enriched implementation of MouseEvent that return mouse coordinates in model-coordinates in addition
to the usual screen-coordinates.
|
| PEMouseInputAdapter |
An abstract adapter class for receiving PEMouseEvent's.
|
| PEMouseInputListener |
The listener for receiving mouse and mouse motion events.
|
| PEPopupMenuFactory |
A factory to create a PEPopupMenu for an EditorKit.
|
| PEProgressBar |
a progress bar that is (currently) used only during GUI initialization on start-up (hence messages are predefined so that
it makes sense during a GUI init, but probably not elsewhere).
|
| PEProgressBar.Test |
test class
|
| PEScrollPane |
A scrollpane that is able to host a PECanvas. |
| PEScrollPane.CenterViewportAction |
Move the view so that (0,0) is at the center of the viewport
|
| PEToggleAction |
A subclass of PEAction suited for toggle-able AbstractButton's, e.g.
|
| PEToolBar |
A subclass of JToolBar that knows how to add PEAction's.
|
| PEToolBar |
The main application toolbar.
|
| PEToolKit |
A collection of static -utilities- methods targetting number formatting, Swing's widget creation, computation
of geometrical properties,...
|
| PicArrowTypeExpression |
"0/1 0/1" arrow type (we take for granted that this string is followed by a LaTeX-picPoint, as in
%Line 0 1 (2.3,4.5)..., possibly with leading whitespaces)
|
| PicAttributeName |
A wrapper for an attribute name that can be pushed into a PicAttributeSet.
|
| PicAttributeSet |
a class that stores non-default graphical attributes (e.g.
|
| PicBezierExpression |
Parser expression for :
|
| PicCircleFrom3Points |
A class implementing either a circle or an arc, whose geometry is specified by a PicEllipse,
yet is further controllable by three additional points :
this may either be a plain circle going through these three points,
or an arc going from P_1 to P_3 through P_2, in which case a pie or a chord may be added as well.
Superclass control-points are still available here, yet geometry is constrained to a circle by
invoking e.g.
|
| PicColorExpression |
jPicEdt syntax (ie lines starting with a %)
color : filled/blacken/whiten/shade
|
| PicDashStatement |
Handles dash statements in jPicEdt-syntax (ie TeX-like comments)
% ...
|
| PicEllipse |
Ellipse or arc, based on parallelogram
The geometrical model of this ellipse (or its arc counterpart) is based on a parallelogram, yet
is equivalent to an ellipse rotated around its center.
|
| PicEllipseExpression |
PicEllipse :
%Ellipse(x0,y0)(width)(height)
%Ellipse(x0,y0)(width,height) filled|whiten|blacken|shade arcStart= arcExtent=
Any string (multiput...)
%End Ellipse
|
| PicEllipseFormatter |
Formats a PicEllipse using macros of the eepic package.
|
| PicEllipseFormatter |
A drawing->LaTeX formater for PicEllipse objects
|
| PicEllipseFormatter |
Formats a PicEllipse using PsTricks macros, including pstricks-add's \\psellipticarc if applicable.
|
| PicEndExpression |
Match "%End XXXX"-like expressions at the beginning of a line (or preceeded by whitespaces),
after skipping as many lines as necessary.
|
| PicGroup |
A concrete implementation of BranchElement that is suited for building groups of elements.
|
| PicGroupExpression |
PicGroup:
%Begin group
...
%End group
|
| PicGroupFormatter |
A formatter for PicGroup objects.
|
| PicLineExpression |
PicLine :
%Line 0 0 (x0,y0)(x1,y1) dash=value
%Line 0 1 (x0,y0)(x1,y1) dash=value
%Line 1 0 (x0,y0)(x1,y1) dash=value
%Line 1 1 (x0,y0)(x1,y1) dash=value (dash is optional)
Any string (\multiput, etc...)
%End Line
|
| PicMultiCurve |
PicMultiCurve is basically an AbstractCurve where each subdivision point has
additionnal features regarding 2nd-order smoothness and symmetry.
|
| PicMultiCurveConvertable |
Specifies Element's that can be converted to a PicMultiCurve
|
| PicNodeConnection |
This class represents a connection between two DefaultLeafElement's.
|
| PicObjectConstants |
Useful constants for the Element interface.
|
| PicParallelogram |
A class implementing a parallelogram.
|
| PicParallelogramFormatter |
Formats a PicParallelogram to the eepic package, using \\path macros, with appropriate filling if any,
or \\dashline macros if dash is positive.
|
| PicParallelogramFormatter |
Formats a PicParallelogram to the LaTeX-picture format.
|
| PicParallelogramFormatter |
Pstricks formatter for PicParallelogram paraects.
|
| PicPoint |
Enhancement of Point2D.Double with convenient formatting methods and constructors.
|
| PicPoint.XComparator |
a comparator b/w PicPoint for X-axis ordering
|
| PicPoint.YComparator |
a comparator b/w PicPoint for Y-axis ordering
|
| PicPointExpression |
An expression for 2D-Point parsing e.g.
|
| PicPolygonExpression |
PicPolygon :
%Polygon (x1,y1)...(xn,yn) dash=value whiten|shade|blacken closed
...
|
| PicPsCurve |
A multicurve, either closed or not, going through a set of control points.
|
| PicRectangleExpression |
%Rectangle(x0,y0)(x1,y1)
or %Rectangle(x0,y0)(x1,y1) filled|blacken|shade|whiten dash=value
Any string
%End Rectangle
|
| PicSmoothPolygon |
A multicurve, either close or not, whose geometry is specified using a polygon, in such a way that the curve snakes
"smoothly" along the polygon.
|
| PicText |
Textual elements, possibly surrounded by a box (currently, only rectangular, oval and circular shapes
are supported).
|
| PicTextFormatter |
An interface that specifies common formatting behaviours for Drawable objects
|
| PicTextFormatter |
A formatter for PicText objects in the PsTricks format :
\\rput[refpoint]{rotation}(x,y){stuff}
where :
stuff can be any of the following :
\\psframebox[param]{text}}
\\pscirclebox[param]{text}}
\\psovalbox[param]{text}}
refpoint = B|b|t for vertical and l|r for horizontal (B = baseline)
rotation = any angle in degree or U,L,D,R,N,W,S or E.
|
| PicVector |
This class encapsulates a geometrical vector (ie it has absolutely no relation with java.util.Vector !).
|
| PointIndexIterator |
An iterator over Element's control-point indices.
|
| Pool |
Offers a means for expressions belonging to the parser-tree to share variables across the tree.
|
| Pool.Key |
Enforces use of strong typing for keys being pushed in the map .
|
| PopupMenuFactory |
A factory used to create a JPopupMenu for an EditorKit.
|
| PsArcExpression |
Parses \\psarc commands :
\\psarc[parameters]{<->}(x0,y0){rad}{angleA}{angleB} ; where at least "arrows" or (x0,y0) args must be included
\\psarc*[parameters]{<->}(x0,y0){rad}{angleA}{angleB} ; idid.
|
| PsBezierExpression |
Rules for parsing cubic splines with a PsTricks syntax :
\\psbezier[parameters]{arrows}(x0,y0)(x1,y1)(x2,y2)(x3,y3)
\\psbezier*[parameters]{arrows}(x0,y0)(x1,y1)(x2,y2)(x3,y3)
or PsTricks's object previously defined by help of a \\newpsobject command.
|
| PsBox |
Parses PsTricks boxes, i.e.
|
| PsCircleExpression |
Quick circle :
\\pscircle[parameters](x0,y0){rad}
\\pscircle*[parameters](x0,y0){rad}
|
| PsEllipseExpression |
Parses \\psellipse commands :
\\psellipse[parameters](x0,y0)(hrad,vrad)
\\psellipse*[parameters](x0,y0)(hrad,vrad)
|
| PsFrameExpression |
\\psframe[parameters](x0,y0)(x1,y1)
\\psframe*[parameters](x0,y0)(x1,y1)
|
| PsObjectExpression |
Handles \\newpsobject{myobj}{ps_object}{par1=val1,...}, for instance
\\newpsobject{myline}{psline}{linecolor=green} (param is optional, though in this case, it'd be pretty useless!)
|
| PsPolygonExpression |
Parses \\pspolygon, \\psdots and \\psline commands :
\\pspolygon[param](2,4)(3,15) // NO ARROW ALLOWED HERE !
\\pspolygon*[param](5,1)(5,8)...(xN,yN)
\\psline[param]{arrows}(5,1)(5,8)...(xN,yN)
\\psline*[param]{arrows}(5,1)(5,8)...(xN,yN)
\\psdots[param,dotstyle=style,dotscale=a b,dotangle=angle]{arrows}(5,1)(5,8)...(xN,yN)
\\psdots*[param]{arrows}(5,1)(5,8)...(xN,yN) (same as above, '*' being unused)
Note : PsPolygon -> close path ; PsLine -> open path ; PsDots -> dots only
|
| PsQDiskExpression |
Quick disk : (streamlines version of \\pscircle*),
\\qdisk(x0,y0)(rad)
|
| PsQLineExpression |
Quick line :
\\qline(x0,y0)(x1,y1)
|
| PsRPutExpression |
Parses PsTricks's \\rput commands, either:
\\rput[refpoint]{rotation}(x,y){stuff}
\\rput*[refpoint]{rotation}(x,y){stuff}
(line-breaks being allowed b/w each "block"), where :
refpoint = B|b|t for vertical and l|r for horizontal (B = baseline), used only for psframebox and rel.
|
| PSTAngleParameter |
Used by PSTParametersExpression to parse statements involving angles, for instance
"hatchangle=45" or "shadowangle=90".
|
| PSTArrowExpression |
Parses Pstricks's arrows, as given by the PsTricks's documentation (p.29).
This is based on the following rules :
an opening "{" ;
"<", ">", "(",...
|
| PSTBooleanExpression |
Used by PSTParametersExpression to parse statements involving true/false parameters values, for instance
"shadow=true" or "shadow=false" ...
|
| PSTColorExpression |
Used by PSTParametersExpression to parse statements involving colours, for instance
"linecolor=green" (predefined colour) or "fillcolor=MyGray" (user-defined colours).
|
| PSTDashExpression |
Parses statements similar to "dash=1pt 3mm" (first opaque, then transparent).
|
| PSTDotStyleExpression |
Parses statements similar to "dotstyle=style" where style is one of PicObjectConstants predefined dot styles.
|
| PSTFillStyleExpression |
Parses statements similar to "fillstyle=style" where style is one of PicObjectConstants predefined fill styles.
|
| PSTInstanciationExpression |
Instanciates a new Element by cloning the given object, when a given tag gets found.
|
| PSTLengthParameter |
Parses statement involving length units (as set by PsTricks's "runit" register),
e.g.
|
| PSTLineStyleExpression |
Parses statements similar to "linestyle=style" where style is one of PicObjectConstants predefined line styles.
|
| PSTParametersExpression |
PsTricks graphics parameters, e.g.
|
| PSTPicPointExpression |
an expression that parses "(x,y)" string (PsTricks-like PicPoint)
and gives the corresponding numerical values to the point number "ptNumber" of the current Element,
possibly using a given EditPointConstraint.
|
| PstricksConstants |
Useful constants used across the jpicedt.format.output.pstricks package.
|
| PstricksContentType |
ContentType for the Pstricks format.
|
| PstricksCustomizer |
a panel for configuring the PstricksFormatter.
|
| PstricksFormatter |
Produces formatters for the PsTricks macro package.
|
| PstricksParser |
Root expression for the Pstricks parser, containing grammar rules for the pstricks format.
|
| PstricksUtilities |
Collection of static methods for the PsTricks format
|
| PstricksViewFactory |
A factory to create a View for a given Element when the underlying content type for
the model is Pstricks.
|
| PsUnitLengthExpression |
Used by PSTParamExpression to parse statement involving the 4 pstricks length registers, that is
"unit=1mm,xunit=1mm,yunit=1mm,runit=1mm" (or pt or cm), where setting "unit" sets "xunit",
"yunit" and "runit" simultaneously.
|
| RegExExpression |
An expression specified by a java.util.regex.Pattern regular expression.
|
| RenderingCustomizer |
a panel for editing rendering-preferences (anti-aliasing,...)
|
| REParserException |
An Exception manager to be used by RE-parsers (i.e.
|
| REParserException.BeginGroupMismatch |
a "begin group" has no matching "end group"
|
| REParserException.BlockMismatch |
a closing delimiter has no matching opening delimiter (see EnclosingExpression)
|
| REParserException.EndGroupMismatch |
a "end group" has no matching "begin group"
|
| REParserException.EndOfPicture |
the end of the picture environment was encoutered.
|
| REParserException.EndOfPictureNotFound |
the end of the picture environment wasn't found in the current Reader.
|
| REParserException.EOF |
the end of the file (or the underlying Reader) was reached abnormally, e.g.
|
| REParserException.IncompleteSequence |
signals an incomplete SequenceExpression
|
| REParserException.NotFoundInFile |
a mandatory expression wasn't found
|
| REParserException.NumberFormat |
aka NumberFormatException
|
| REParserException.NumberSign |
signals an error concerning the sign of a number (see NumericalExpression)
|
| REParserException.SyntaxError |
a syntax error has occured ; should be used as a last resort, when
no specific exception message applies.
|
| RepeatExpression |
an expression that represents a pattern repeating a given number of times
|
| RootExpression |
This is the super-class for head-expressions that contain grammar rule for a given format.
|
| RotateTool |
A MouseTool used to rotate a target Element using a origin point and a mobile point used to
compute the rotation angle..
|
| RunExternalCommand |
A class implementing methods for calling external processes like latex, (x)dvi, ghostscript...
|
| ScaleTool |
A MouseTool used to scale a target Element using a source and a destination vector.
|
| SelectionEvent |
Class for notifications of changes that occured in a SelectionHandler (strongly mimics
javax.swing.event.CaretEvent)
|
| SelectionEvent.EventType |
enumeration for SelectionEvent types
|
| SelectionHandler |
a SelectionHandler allows to manage selection-related behaviours for a given instance of
Drawing. |
| SelectionListener |
Interface for an observer to receive notifications of changes made to a SelectionHandler
|
| SelectionTool |
This generic mouse-tool is dedicated to applying MouseTransform's to elements of a Drawing, following a uniform sequence of
mouse-events.
|
| SequenceExpression |
An expression that represents a sequence of expressions to be matched exactly in
the same order they're being added to the sequence.
|
| ShortcutsCustomizer |
A panel for editing keyboard shortcuts (i.e.
|
| StarExpression |
Handles (usually optional) "*" after \\psframebox,\\pspolygon,...
|
| StatementExpression |
An expression for "statement"-parsing, i.e.
|
| StyleConstants |
Utility class to get or set attributes in a type-safe manner
|
| SystemOutUtilities |
A class that allow redirection of stderr and/or stdout to a log file.
|
| TestBoard |
test class
|
| TestCanvas |
Test class incorporating a BSH interpreter facility for efficient debugging.
|
| TextEditable |
An abstract class for Element's that have a textual representation, and [pending:removed as of 1.3.2]
whose text can be graphically edited
|
| TransferableGraphic |
Wrapper for Element's that can be transfered to/from a Clipboard.
|
| UIColorCustomizer |
a panel for UI colours editing (grid, desktop,...)
[pending] selection highlighter colour
|
| UnitLengthExpression |
\\unitlength value
\\setlength{\\unitlength}{value}
where value's permitted syntaxs are : 0.11, 0.11mm, 0.11cm, 0.11pt with possible leading whitespaces before the "unit".
|
| UserDefinedColorExpression |
Parse statement defining user-colours, that is :
\\newgray{user-def colour name}{num} (where num is a gray scale specification b/w 0 and 1)
\\newrgbcolor{user-def-colour-name}{num1 num2 num3} (where num are numbers b/w 0 and 1)
\\newhsbcolor{user-def-colour-name}{num1 num2 num3} (where num are numbers b/w 0 and 1)
\\newcmykcolor{user-def-colour-name}{num1 num2 num3 num4} (where num are numbers b/w 0 and 1)
Colour names may contain letters and numbers.
|
| Version |
contains static methods that return version information
|
| View |
a View is a graphic representation of a Element.
|
| ViewConstants |
Useful constants for implementation of the View and Highlighter interfaces.
|
| ViewFactory |
A factory to create a View for a given Element.
|
| ViewFormattedStringDialog |
This class implements a dialog box that displays the LaTeX/PsTricks/...
|
| WhiteSpaces |
Multiple white spaces (w/o line-feeds)
|
| WhiteSpacesOrEOL |
multiple white spaces and/or '\n'
|
| WholeNumberField |
A JtextField that accept only WholeNumbers
|
| WildCharExpression |
a RegExp that represents a single occurence of a wild-char, i.e.
|
| WordExpression |
A RegExp that parses a word, that is, a string :
either composed of letters only, or letters and digits only (see java.lang.Character.isLetter() for details),
or terminated by the specified end-delimiter (in which case it may contain chars not restricted to letters)
|
| XmlAttributeSet |
A map that contains XML-like name=value pairs, to be ultimately formatted as XML.
|
| ZoomEvent |
Class for notifications of zoom-factor changes sourced by a PECanvas.
|
| ZoomListener |
Interface for an observer to receive notifications of changes made to a zoom factor in an instance of PECanvas.
|
| ZoomTool |
A mouse tool for EditorKit, which allows to zoom in and out while retaining the current scene at the center
of the drawing sheet.
|