¡Puntuación alta para la impresora Java! ! ! ! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente! ¡urgente!
Mira aquí y te ayudaré a encontrarlo también.
Utilice un archivo de programa que implemente la interfaz de impresión JAVA para imprimir el contenido del cuadro de texto (a través de la impresora).
/descargas 76/código fuente/Java/95302943 área de texto imprimible. rar
Implementación del código fuente de instancia de documento imprimible en java
Círculo circundante;
Importar Java.awt.*;
Importar Java.awt.print.*;
Importar Java.awt.geom.*;
importar java.awt.font.*;
importar javax.swing.*;
importar javax.swing.text.*;
importar Java.util *;
/**
*Esta clase implementa las interfaces paginables e imprimibles y permite
* imprimir usando java.awt.print El contenido de cualquier. JTextComponent
*API de impresión.
**/
La clase pública PrintableDocument implementa paginación e impresión {
Ver el directorio raíz //La vista raíz que se va a imprimir
Formato PageFormat; //Papel más orientación de página
Factor de escala doble; //Cuánto escalar antes de imprimir
Entero;
Altura de doble impresión
Rectangle drawRect //Dibujar el rectángulo del documento
//¿Qué tan tolerantes somos con el resultado final para la prevención de viudas/huérfanos?
Doble final estático MARGIN _ ADJUST = .97
//La fuente que utilizamos para imprimir los números de página
Fuente final estática headerFont = new font(" Serif ", font.plain, 12);
/**
* Este constructor permite imprimir el contenido de cualquier JTextComponent
* Usando el formato de página predeterminado y el factor de escala predeterminado. El factor de escala predeterminado
* es 0,75 porque la fuente predeterminada es demasiado grande.
*/
documento público imprimible (componente de texto JTextComponent){
this(textComponent, new PageFormat(),. 75);
}
/**
* Este constructor permite imprimir el contenido de cualquier JTextComponent
* utilizando cualquier objeto PageFormat especificado y cualquier factor de escala.
**/
Documento público imprimible (JTextComponent textComponent, formato PageFormat,
factor de escala doble)
{
//Recuerda el formato de la página y solicítale el área imprimible
this.format = format
this.scalefactor =scale factor;
this . printx = formato. getimageablex()/factor de escala;
this. printy = formato. getimageabley()/factor de escala. factor de escala;
esto. altura de impresión = formato. getimageableheight()/factor de escala;
ancho de papel doble = formato. >//Obtener el documento y su elemento raíz del componente de texto
document document = text componente . get document()
elemento raíz element = document . /p> p>
//Obtenga EditorKit y su ViewFactory del componente de texto
editor kit editor = componente de texto getui(). getEditorKit(componente de texto);
view factory view factory = editor kit ;
//Utilice ViewFactory para crear un objeto de vista raíz para el documento
//Este es el objeto que queremos imprimir.
root = view factory . create(root element);
La arquitectura de texto Swing requiere que llamemos a setParent() en
//Nuestra vista raíz. Para hacer esto,
//necesitamos un objeto de vista que pueda ser emparentado. Usamos
// una implementación personalizada definida a continuación.
root . set parent(new parent view(root, viewFactory, componente de texto));
//Dile a la vista qué ancho debe formatear la página; >
//Para ajustarse a este ancho. La altura no es importante aquí
root.setSize((float)printWidth, (float)print height);
//Ahora la vista se ha formateado de acuerdo con el ancho especificado.
//Pregunta qué altura tiene.
altura doble del documento = root .
y_axis);
//Establece el rectángulo que le indica a la vista dónde dibujarse
//Usaremos esto en otros métodos de esta clase.
drawRect = new Triangle(0, 0, (int)printWidth 1, (int)document height 1);
//Ahora, si el documento tiene más de una página, tengo que
p>
// Averiguar dónde está el salto de página.
if(document height gt;printHeight) paginate(root,drawRect);
//Una vez que lo dividimos en páginas, calcula cuántas páginas hay.
numPages = longitudes de página. size() 1;
}
//Este es el desplazamiento inicial de la página que estamos procesando actualmente
p>double pageStart = 0;
/**
*Este método atraviesa las subvistas de la vista especificada,
*de forma recursiva según sea necesario, e Insertar saltos de página cuando sea necesario.
*Inicialmente intenta evitar "viudas" y "huérfanos".
**/
Paginación vacía protegida (vista v, asignación rectangular 2D) {
//Averigüe qué tan alta es esta vista y dígale que asigne
//El espacio entre sus nodos secundarios
doble mi altura = v. getpreferredspan(view.y_axis);
v.setSize((( float) printWidth, (float)my height);
//Ahora recorre cada nodo secundario
int num kids = v. getview count();
for (int I = 0; i ltnumkidsi ) {
view kid = v . get view(I); //Este es el niño que estamos mirando
//descúbrelo. tamaño y posición
forma forma de niño = v. getchildallocation(I, asignación);
if (kidshape == null) continuar;
rectángulo 2d kidbox = kidshape . getbounds 2d();
//Esta es la coordenada Y de la parte inferior del nodo secundario
double kid pos = kid box gety() kid box. ()- pageStart;
//Si este es el primer subgrupo de un grupo, entonces queremos asegurarnos de que
//no permanezca en la parte inferior del página por sí sola.
//En otras palabras, queremos evitar las "viudas"
if((numkids gt; 1); amt ampamt(i == 0)) {
//Si no está cerca del final de la página, muévase
//Al siguiente nodo secundario
if (kid pos lt; printY print height * MARGIN _ ADJUST) continuar ;
//De lo contrario, este niño está cerca del final de la página, por lo que
//Página antes de este niño y colócalo en
//Nueva página.
break page(kidbox . gety());
Continuar
}
//Si este es el final de un grupo Un subgrupo, no queremos que
// aparezca solo en la parte superior de la nueva página, así que permítale
// pasar el margen inferior si es necesario. . Esto ayuda
//prevenir la "huérfana"
if((numkids gt; 1); amt ampamt(i == numkids-1)) {
//Si cabe normalmente, continúa con el siguiente
if (kid pos lt; printY printHeight) continue;
//De lo contrario, si cabe en el espacio extra, rompe
//Página al final del grupo
if(kid pos lt; printY print height/MARGIN _ ADJUST){
romper página(allocation . asignación gety() .getheight());
Continuar;
}
}
//Si el niño no es el primero en el grupo o El último, luego usamos
//margen inferior estricto. Si el niño se ajusta a la página,
// luego pasa al siguiente nodo secundario.
if (kid pos lt; printY printHeight) continue;
//Si llegas aquí, el niño no es apto para esta página. Si
//no hay niños, vaya a la página anterior a este niño y continúe.
if (kid.getViewCount() == 0) {
romper página(kidbox . gety());
Continuar
}
//Si llegamos aquí, entonces este niño no encaja en esta página, pero
//tiene sus propios hijos, así que recursivamente vea si hay alguno. de esos niños
//caben en la página.
paginate(kid, kidbox);
}
}
//Para un documento de n páginas, esta lista almacena The longitud de la página
// 0 a n-2. Supongamos que la última página tiene la longitud completa
ArrayList longitudes de página = new ArrayList();
//Para un documento de n páginas, esta lista se almacena
/ /página 1 a página n-1. El desplazamiento de la página 0 es siempre 0
Desplazamientos de página ArrayList = new ArrayList();
/**
*En la página de coordenadas Y especificada. Almacenar elementos esenciales
* Información en listas de longitud de página y desplazamiento de página
**/
Invalidar paginación (doble y) {
doble longitud de página = y-pageStart-printY;
pageStart = y-printY;
longitud de página add(new Double(longitud de página));
página compensaciones . add(new Double(pageStart));
}
/**Devuelve el número de página. Este es un método paginable.
*/
public int getNumberOfPages(){ return numPages;}
/**
*Devuelve el objeto PageFormat de la página especificada. Este es un
*método paginable. Esta implementación utiliza las páginas
* calculadas en el objeto PageFormat devuelto. PrinterJob utilizará esta
* como área de recorte, lo que evitará
* que el documento se dibuje dentro de los márgenes superior e inferior.
**/
formato de página pública getpage format(int pagenum){
//En la última página, solo se muestra el formato de página especificado por el usuario. devuelto
p>
if (pagenum == numPages-1) devuelve el formato;
//De lo contrario, encuentra la altura de la página y devuelve un
//Formato de página apropiado.
Doble elemento de página = ((Doble)elementos de página . get(pagenum)). valor doble();
formato de página f = (formato de página)formato .clonar();
papel p = f . if(f . obtener orientación() = = formato de página. retrato)
p . setimageablearea(printX * factor de escala, printY * factor de escala,
imprimir Ancho * factor de escala, página longitud * factor de escala);
Otros
p . setimageablearea(printY * factor de escala, printX * factor de escala,
pageLength * factor de escala, ancho de impresión * factor de escala);
f . establecer papel(p);
Retorno f
}
/**
* Este método paginable devuelve el objeto imprimible especificado
*página. Debido a que esta clase implementa paginable e imprimible, simplemente
* devuelve esto.
**/
imprimible público get Imprimible(int pagenum){ return this;}
/**
*Esto es Método imprimible básico para imprimir la página especificada
**/
public int print(Graphics g, PageFormat format, int pageIndex) {
//Intentando devoluciones un código de error al imprimir más allá del final del documento
if (índice de página gt; = numPages) devuelve NO_SUCH_PAGE
//Convierte el objeto gráfico para que podamos usar operaciones Java2D
gráficos 2d G2 = (gráficos 2d)g;
//Traducir para ajustarse a los márgenes superior e izquierdo
G2 . format .getimageabley());
//Escale la página según el factor de escala especificado
g2.scale(scalefactor, scale factor);
/ /In Muestra el número de página centrado en el área del margen superior.
//Establece una nueva área de recorte para que podamos dibujar en el margen superior
//Pero recuerda el área de recorte original para que podamos restaurarla
si (índice de página gt; 0) {
forma clip original = g. get clip();
g2.setClip(nuevo rectángulo(0, (int)- printY,
(int)printWidth, (int)printY));
//Calcule el título a mostrar, mídalo y luego muéstrelo
string numString = "-" (índice de página 1) "-";
//Obtener la cadena y el tamaño de fuente
FontRenderContext frc = G2 . rectángulo 2d numBounds = fuente del encabezado. getstring metrics(numString, frc);
establecer fuente de fuente (. fuente del encabezado); //Establecer fuente
G2 . set color(color . black); //Imprimir con tinta negra
g2.drawString(numString, //Mostrar cadena
p>
(int)((print width-numbounds . getwidth())/2),
(int)(-(printY-numbounds . getheight())/2
(int)(-(printY-numbounds . getheight()))/2 p>
metrics . getascent()));
G2 . /Restaurar el área de recorte
}
/ /Obtener la posición inicial y la longitud de la página en el documento
double pageStart = 0.0, pageLength = printHeight
if (índice de página gt; 0)
pageStart = ((Doble)desplazamientos de página. get(índice de página-1)). valor doble();
si (índice de página lt; número de página numérico - 1)
longitud de página = ((Doble)longitudes de página. get(índice de página)). double value();
//Desplácese para alinear la parte apropiada del documento
//La esquina superior izquierda de la página
g2.translate( 0.0, -pageStart );
//Ahora dibuja el documento completo. Debido al área de recorte,
//sólo se dibujará realmente la parte requerida del documento
//el papel.
root.paint(g2, drawRect);
//Finalmente devuelve un código de éxito
Devuelve PAGE _ EXISTS
}
Public void jobprint(){
trabajo de impresora = trabajo de impresora . getprinterjob();
job.setPrintable(este, trabajo. página predeterminada()) ;
if(job.printDialog()){
Pruebe {
job . >
catch (PrinterException ex) {
}
}
}
/**
*Esta clase interna es la implementación específica de View, con una
* implementación de varios métodos clave. Una instancia de esta clase
* sirve como objeto principal del objeto de vista raíz que queremos imprimir
**/
clase estática ParentView extiende la vista{
p>ViewFactory viewFactory//ViewFactory de la jerarquía de vistas
Contenedor contenedor; //Contenedor de la jerarquía de vistas
public ParentView(vista v, fábrica de vistas) ver fábrica, contenedor Contenedor)
{
super(v . getelement());
this . p>this. container = container;
}
//Estos métodos devuelven la información clave requerida
//Ver jerarquía.
public view factory getview factory(){ return view factory;}
Contenedor público get Container(){ return Container;}
//Estos métodos son Las vistas son abstracciones, por lo que debemos proporcionar
// implementaciones virtuales de ellas incluso si nunca se usan.
pintura vacía pública (gráfico g, asignación de forma){}
public float getPreferredSpan(int axis){ return 0.0f;}
public int viewToModel( Punto flotante x, punto flotante y, forma a, posición Bias[] sesgo) {
Return 0;
}
ModelToView de forma pública (int pos) , Forma a, Desviación b)
Lanzar BadLocationException {
Devolver a;
}
}
<. p>}