guiserver/java/CanvasWidget.java

   1 //
   2 //  CanvasWidget.java
   3 //  guiserver
   4 //
   5 //  Created by Lutz Mueller on 6/8/07.
   6 //
   7 //
   8 //    Copyright (C) 2007 Lutz Mueller
   9 //
  10 //    This program is free software: you can redistribute it and/or modify
  11 //    it under the terms of the GNU General Public License as published by
  12 //    the Free Software Foundation, either version 3 of the License, or
  13 //    (at your option) any later version.
  14 //
  15 //    This program is distributed in the hope that it will be useful,
  16 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 //    GNU General Public License for more details.
  19 //
  20 //    You should have received a copy of the GNU General Public License
  21 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 //
  23
  24
  25 import java.awt.*;
  26 import java.awt.color.*;
  27 import java.awt.event.*;
  28 import java.awt.geom.*;
  29 import java.awt.print.*;
  30 import java.awt.image.BufferStrategy;
  31 import java.awt.image.BufferedImage;
  32 import javax.swing.*;
  33 import javax.imageio.ImageIO;
  34 import java.util.*;
  35 import java.io.File;
  36 import java.io.IOException;
  37
  38 @SuppressWarnings("unchecked")
  39 public class CanvasWidget extends gsObject {
  40
  41 static CanvasWidget currentCanvas;
  42
  43 Vector drawobjects = new Vector();
  44
  45 MyCanvas canvas;
  46 //Window ownerWindow;
  47 double translationX = 0;
  48 double translationY = 0;
  49 double theta = 0;
  50 double scaleX = 1;
  51 double scaleY = 1;
  52 Color background = null;
  53 Stroke currentStroke;
  54 Color currentPaint;
  55 //AffineTransform transform = AffineTransform.getScaleInstance(1.0, 1.0);
  56 AffineTransform transform = null;
  57 AlphaComposite currentComposite;
  58 Font currentFont = null;
  59 boolean antiAliasing = true;
  60 boolean visible = true;
  61
  62 String mouseClickedEvent;
  63 String mouseEnteredEvent;
  64 String mouseExitedEvent;
  65 String mousePressedEvent;
  66 String mouseReleasedEvent;
  67 String mouseDraggedEvent;
  68 String mouseMovedEvent;
  69 String mouseWheelMovedEvent;
  70
  71 boolean mousePressedTags = false;
  72 boolean mouseReleasedTags = false;
  73 boolean mouseClickedTags = false;
  74 boolean mouseMovedTags = false;
  75
  76 public CanvasWidget(StringTokenizer params)
  77         {
  78         id = params.nextToken();
  79         canvas = new MyCanvas();
  80
  81         component = canvas;
  82
  83         // if canvas is not Canvas but JPanel
  84         container = canvas;
  85         jcomponent = canvas;
  86
  87         CanvasWidget.currentCanvas = this;
  88
  89         currentStroke = new BasicStroke();
  90         currentPaint = new Color(0,0,0);
  91
  92         scaleX = 1.0;
  93         scaleY = 1.0;
  94
  95         gsObject.widgets.put(id, this);
  96         }
  97
  98 public void g2Canvas(StringTokenizer tokens)
  99         {
 100         CanvasWidget.currentCanvas = this;
 101         }
 102
 103 public void g2Translation(StringTokenizer tokens)
 104         {
 105         translationX = Float.parseFloat(tokens.nextToken());
 106         translationY = Float.parseFloat(tokens.nextToken());
 107         }
 108
 109 public void g2Scale(StringTokenizer tokens)
 110         {
 111         scaleX = Float.parseFloat(tokens.nextToken());
 112         scaleY = Float.parseFloat(tokens.nextToken());
 113         }
 114
 115 public void g2Rotation(StringTokenizer tokens)
 116         {
 117         double rotation = Float.parseFloat(tokens.nextToken());
 118         theta = 2.0 * Math.PI * rotation / 360.0;
 119         }
 120
 121 public void g2Transform(StringTokenizer tokens)
 122         {
 123         double m00 = Float.parseFloat(tokens.nextToken());
 124         double m01 = Float.parseFloat(tokens.nextToken());
 125         double m02 = Float.parseFloat(tokens.nextToken());
 126         double m10 = Float.parseFloat(tokens.nextToken());
 127         double m11 = Float.parseFloat(tokens.nextToken());
 128         double m12 = Float.parseFloat(tokens.nextToken());
 129
 130         //transform.concatenate(new AffineTransform(m00, m01, m02, m10, m11, m12));
 131         }
 132
 133 public void g2Stroke(StringTokenizer tokens)
 134         {
 135         float strokeWidth = Float.parseFloat(tokens.nextToken());
 136         int strokeCap = BasicStroke.CAP_BUTT;
 137         int strokeJoin = BasicStroke.JOIN_MITER;
 138         float strokeMiterLimit = (float)10.0;
 139
 140         if(tokens.hasMoreTokens())
 141                 {
 142                 String cap = tokens.nextToken();
 143                 if(cap.equals("round")) strokeCap = BasicStroke.CAP_ROUND;
 144                 else if(cap.equals("square")) strokeCap = BasicStroke.CAP_SQUARE;
 145                 else strokeCap = BasicStroke.CAP_BUTT;
 146                 }
 147
 148         if(tokens.hasMoreTokens())
 149                 {
 150                 String join = tokens.nextToken();
 151                 if(join.equals("round")) strokeJoin = BasicStroke.JOIN_BEVEL;
 152                 else if(join.equals("square")) strokeJoin = BasicStroke.JOIN_ROUND;
 153                 else strokeJoin = BasicStroke.JOIN_MITER;
 154                 }
 155
 156         if(tokens.hasMoreTokens())
 157                 strokeMiterLimit = Float.parseFloat(tokens.nextToken());
 158
 159         currentStroke = new BasicStroke(strokeWidth, strokeCap, strokeJoin, strokeMiterLimit);
 160         }
 161
 162 public void g2Paint(StringTokenizer tokens)
 163         {
 164         float R, G, B;
 165         float alpha;
 166
 167         R = Float.parseFloat(tokens.nextToken());
 168         G = Float.parseFloat(tokens.nextToken());
 169         B = Float.parseFloat(tokens.nextToken());
 170
 171         if(tokens.hasMoreTokens())
 172                 alpha = Float.parseFloat(tokens.nextToken());
 173         else
 174                 alpha = 1;
 175
 176         currentPaint = new Color(R, G, B, alpha);
 177         }
 178
 179 public void g2Update(StringTokenizer tokens)
 180         {
 181         canvas.repaint();
 182         }
 183
 184 public void g2Export(StringTokenizer tokens)
 185         {
 186         String path = Base64Coder.decodeString(tokens.nextToken());
 187         int width = canvas.getWidth();
 188         int height = canvas.getHeight();
 189
 190         if(tokens.hasMoreTokens())
 191                 {
 192                 width = Integer.parseInt(tokens.nextToken());
 193                 height = Integer.parseInt(tokens.nextToken());
 194                 }
 195
 196         canvas.export(path, "PNG", width, height);
 197         }
 198
 199 public void g2Print(StringTokenizer tokens)
 200         {
 201         }
 202
 203 public void setBackground(StringTokenizer tokens)
 204         {
 205         float R, G, B;
 206         float alpha;
 207
 208         R = Float.parseFloat(tokens.nextToken());
 209         G = Float.parseFloat(tokens.nextToken());
 210         B = Float.parseFloat(tokens.nextToken());
 211
 212         if(tokens.hasMoreTokens())
 213                 alpha = Float.parseFloat(tokens.nextToken());
 214         else
 215                 alpha = 1;
 216
 217         background = new Color(R, G, B, alpha);
 218
 219         component.setBackground(background);
 220         }
 221
 222 public void setFont(StringTokenizer tokens)
 223         {
 224         String name = Base64Coder.decodeString(tokens.nextToken());
 225         int style = 0;
 226         int size = 12;
 227
 228         if(tokens.hasMoreTokens())
 229                 size = Integer.parseInt(tokens.nextToken());
 230
 231         while(tokens.hasMoreTokens())
 232                 {
 233                 String sstyle = tokens.nextToken();
 234                 if(sstyle.equals("plain")) style = style | Font.PLAIN;
 235                 if(sstyle.equals("bold")) style = style | Font.BOLD;
 236                 if(sstyle.equals("italic")) style = style | Font.ITALIC;
 237                 }
 238
 239         currentFont = new Font(name, style, size);
 240         component.setFont(currentFont);
 241         }
 242
 243
 244 public void setAntiAliasing(StringTokenizer tokens)
 245         {
 246         antiAliasing = tokens.nextToken().equals("true");
 247         }
 248
 249 // create shapes
 250
 251 public void drawLine(StringTokenizer tokens)
 252         {
 253         new LineShape(tokens);
 254         }
 255
 256 public void drawRectangle(StringTokenizer tokens)
 257         {
 258         new RectangleShape(tokens);
 259         }
 260
 261 public void fillRectangle(StringTokenizer tokens)
 262         {
 263         new FilledRectangleShape(tokens);
 264         }
 265
 266 public void drawRoundRect(StringTokenizer tokens)
 267         {
 268         new RoundRectangleShape(tokens);
 269         }
 270
 271 public void fillRoundRect(StringTokenizer tokens)
 272         {
 273         new FilledRoundRectangleShape(tokens);
 274         }
 275
 276 public void drawEllipse(StringTokenizer tokens)
 277         {
 278         new EllipseShape(tokens);
 279         }
 280
 281 public void fillEllipse(StringTokenizer tokens)
 282         {
 283         new FilledEllipseShape(tokens);
 284         }
 285
 286 public void drawCircle(StringTokenizer tokens)
 287         {
 288         new CircleShape(tokens);
 289         }
 290
 291 public void fillCircle(StringTokenizer tokens)
 292         {
 293         new FilledCircleShape(tokens);
 294         }
 295
 296 public void drawArc(StringTokenizer tokens)
 297         {
 298         new ArcShape(tokens);
 299         }
 300
 301 public void fillArc(StringTokenizer tokens)
 302         {
 303         new FilledArcShape(tokens);
 304         }
 305
 306 public void drawPolygon(StringTokenizer tokens)
 307         {
 308         new PolygonShape(tokens);
 309         }
 310
 311 public void fillPolygon(StringTokenizer tokens)
 312         {
 313         new FilledPolygonShape(tokens);
 314         }
 315
 316 public void drawPath(StringTokenizer tokens)
 317         {
 318         new PathShape(tokens);
 319         }
 320
 321 public void drawText(StringTokenizer tokens)
 322         {
 323         new TextShape(tokens);
 324         }
 325
 326 public void drawImage(StringTokenizer tokens)
 327         {
 328         new ImageShape(tokens);
 329         }
 330
 331 // register mouse events
 332
 333 public void registerMouseClicked(StringTokenizer tokens)
 334         {
 335         mouseClickedEvent = tokens.nextToken();
 336         if(tokens.hasMoreTokens())
 337                 mouseClickedTags = tokens.nextToken().equals("true");
 338         }
 339
 340 public void registerMousePressed(StringTokenizer tokens)
 341         {
 342         mousePressedEvent = tokens.nextToken();
 343         if(tokens.hasMoreTokens())
 344                 mousePressedTags = tokens.nextToken().equals("true");
 345         }
 346
 347 public void registerMouseRelease(StringTokenizer tokens)
 348         {
 349         mouseReleasedEvent = tokens.nextToken();
 350         if(tokens.hasMoreTokens())
 351                 mouseReleasedTags = tokens.nextToken().equals("true");
 352         }
 353
 354 public void registerMouseExited(StringTokenizer tokens)
 355         {
 356         mouseExitedEvent = tokens.nextToken();
 357         }
 358
 359 public void registerMouseEntered(StringTokenizer tokens)
 360         {
 361         mouseEnteredEvent = tokens.nextToken();
 362         }
 363
 364 public void registerMouseDragged(StringTokenizer tokens)
 365         {
 366         mouseDraggedEvent = tokens.nextToken();
 367         }
 368
 369 public void registerMouseMoved(StringTokenizer tokens)
 370         {
 371         mouseMovedEvent = tokens.nextToken();
 372         if(tokens.hasMoreTokens())
 373                 mouseMovedTags = tokens.nextToken().equals("true");
 374         }
 375
 376 public void registerMouseWheel(StringTokenizer tokens)
 377         {
 378         mouseWheelMovedEvent = tokens.nextToken();
 379         }
 380
 381 // manipulate shapes
 382
 383 public void deleteTaggedShape(StringTokenizer tokens)
 384         {
 385         String label = tokens.nextToken();
 386         boolean updateFlag = tokens.nextToken().equals("true");
 387         Vector filteredObjects = new Vector();
 388         Shape aShape;
 389
 390         for(int i = 0; i < drawobjects.size(); i++)
 391                 {
 392                 aShape = (Shape)drawobjects.elementAt(i);
 393                 if(!aShape.tag.equals(label))
 394                         filteredObjects.add(aShape);
 395                 }
 396
 397         drawobjects = filteredObjects;
 398         if(updateFlag) canvas.repaint();
 399         }
 400
 401 public void moveTaggedShape(StringTokenizer tokens)
 402         {
 403         String label = tokens.nextToken();
 404         int dx = Integer.parseInt(tokens.nextToken());
 405         int dy = Integer.parseInt(tokens.nextToken());
 406         boolean updateFlag = tokens.nextToken().equals("true");
 407
 408         Shape aShape;
 409
 410         for(int i = 0; i < drawobjects.size(); i++)
 411                 {
 412                 aShape = (Shape)drawobjects.elementAt(i);
 413                 if(aShape.tag.equals(label))
 414                         {
 415                         aShape.X += dx;
 416                         aShape.Y += dy;
 417                         }
 418                 }
 419
 420         if(updateFlag) canvas.repaint();
 421         }
 422
 423 public void translateTaggedShape(StringTokenizer tokens)
 424         {
 425         String label = tokens.nextToken();
 426         double X = Float.parseFloat(tokens.nextToken());
 427         double Y = Float.parseFloat(tokens.nextToken());
 428         boolean updateFlag = tokens.nextToken().equals("true");
 429         Shape aShape;
 430
 431         for(int i = 0; i < drawobjects.size(); i++)
 432                 {
 433                 aShape = (Shape)drawobjects.elementAt(i);
 434                 if(aShape.tag.equals(label))
 435                         aShape.transform.translate(X, Y);
 436                 }
 437
 438         if(updateFlag) canvas.repaint();
 439         }
 440
 441
 442 public void rotateTaggedShape(StringTokenizer tokens)
 443         {
 444         String label = tokens.nextToken();
 445         double theta = Float.parseFloat(tokens.nextToken());
 446         int X = Integer.parseInt(tokens.nextToken());
 447         int Y = Integer.parseInt(tokens.nextToken());
 448         boolean updateFlag = tokens.nextToken().equals("true");
 449         Shape aShape;
 450
 451         theta = 2.0 * Math.PI * theta / 360.0;
 452
 453         for(int i = 0; i < drawobjects.size(); i++)
 454                 {
 455                 aShape = (Shape)drawobjects.elementAt(i);
 456                 if(aShape.tag.equals(label))
 457                         aShape.transform.rotate(theta, X, Y);
 458                 }
 459
 460         if(updateFlag) canvas.repaint();
 461         }
 462
 463 public void scaleTaggedShape(StringTokenizer tokens)
 464         {
 465         String label = tokens.nextToken();
 466         double sx = Float.parseFloat(tokens.nextToken());
 467         double sy = Float.parseFloat(tokens.nextToken());
 468         boolean updateFlag = tokens.nextToken().equals("true");
 469         Shape aShape;
 470
 471         for(int i = 0; i < drawobjects.size(); i++)
 472                 {
 473                 aShape = (Shape)drawobjects.elementAt(i);
 474                 if(aShape.tag.equals(label))
 475                         aShape.transform.scale(sx, sy);
 476                 }
 477
 478         if(updateFlag) canvas.repaint();
 479         }
 480
 481 public void shearTaggedShape(StringTokenizer tokens)
 482         {
 483         String label = tokens.nextToken();
 484         double shx = Float.parseFloat(tokens.nextToken());
 485         double shy = Float.parseFloat(tokens.nextToken());
 486         boolean updateFlag = tokens.nextToken().equals("true");
 487         Shape aShape;
 488
 489         for(int i = 0; i < drawobjects.size(); i++)
 490                 {
 491                 aShape = (Shape)drawobjects.elementAt(i);
 492                 if(aShape.tag.equals(label))
 493                         aShape.transform.shear(shx, shy);
 494                 }
 495
 496         if(updateFlag) canvas.repaint();
 497         }
 498
 499 public void hideTaggedShape(StringTokenizer tokens)
 500         {
 501         String label = tokens.nextToken();
 502         boolean updateFlag = tokens.nextToken().equals("true");
 503         Shape aShape;
 504
 505         for(int i = 0; i < drawobjects.size(); i++)
 506                 {
 507                 aShape = (Shape)drawobjects.elementAt(i);
 508                 if(aShape.tag.equals(label))
 509                         aShape.visible = false;
 510                 }
 511
 512         if(updateFlag) canvas.repaint();
 513         }
 514
 515
 516 public void showTaggedShape(StringTokenizer tokens)
 517         {
 518         String label = tokens.nextToken();
 519         boolean updateFlag = tokens.nextToken().equals("true");
 520         Shape aShape;
 521
 522         for(int i = 0; i < drawobjects.size(); i++)
 523                 {
 524                 aShape = (Shape)drawobjects.elementAt(i);
 525                 if(aShape.tag.equals(label))
 526                         aShape.visible = true;
 527                 }
 528
 529         if(updateFlag) canvas.repaint();
 530         }
 531
 532
 533 public void orderTaggedShapes(StringTokenizer tokens)
 534         {
 535         String label;
 536         Shape aShape;
 537
 538         Vector orderedTags = new Vector();
 539
 540         while(tokens.hasMoreTokens())
 541                 {
 542                 label = tokens.nextToken();
 543                 for(int i = 0; i < drawobjects.size(); i++)
 544                         {
 545                         aShape = (Shape)drawobjects.elementAt(i);
 546 //                      System.out.println("comparing:" + label + "<->" + aShape.tag);
 547                         if(aShape.tag.equals(label))
 548                                 {
 549                                 orderedTags.add(aShape);
 550 //                              System.out.println("adding->" + aShape.tag);
 551                                 }
 552                         }
 553                 }
 554
 555         drawobjects = orderedTags;
 556         }
 557
 558 class MyCanvas extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener, Printable  {
 559
 560         public MyCanvas() {
 561                 super();
 562
 563                 // if canvas extends JPanel
 564                 if(guiserver.DOUBLE_BUFFERING)
 565                         this.setDoubleBuffered(true);
 566
 567                 addMouseListener(this);
 568                 addMouseMotionListener(this);
 569                 addMouseWheelListener(this);
 570                 }
 571
 572         public void update(Graphics g)
 573                 {
 574                 if(guiserver.MAC_OS_X) super.update(g);
 575                 else paint(g);
 576                 }
 577
 578         public void paint(Graphics g)
 579                 {
 580                 Graphics2D g2;
 581 //              BufferStrategy myStrategy = null;
 582
 583 /* only if canvas extends Canvas
 584                 if(guiserver.DOUBLE_BUFFERING)
 585                         {
 586                         try {
 587                                 this.createBufferStrategy(2);
 588                                 }
 589                         catch (Exception evt)
 590                                 {
 591                                 System.out.println("event: =>" + evt);
 592                                 }
 593
 594
 595                         myStrategy = this.getBufferStrategy();
 596                         Graphics myg = myStrategy.getDrawGraphics();
 597                         g2 = (Graphics2D)myg;
 598                         }
 599                 else
 600 */
 601                         g2 = (Graphics2D)g;
 602
 603                 render(g2);
 604
 605                 /* only used if canvas is Canvas
 606                 if(guiserver.DOUBLE_BUFFERING)
 607                         {
 608                         myStrategy.show();
 609                         g2.dispose();
 610                         }
 611                 */
 612                 }
 613
 614
 615         public void render(Graphics2D g2)
 616                 {
 617                 if(background != null) g2.setColor(background);
 618
 619                 // fill background
 620                 if(background != null)
 621                         {
 622                         g2.setPaint(background);
 623                         g2.fillRect(0, 0, canvas.getWidth(), canvas.getHeight());
 624                         }
 625
 626                 g2.translate(translationX, translationY);
 627                 g2.scale(scaleX, scaleY);
 628                 g2.rotate(theta);
 629
 630                 AffineTransform normalTransform = g2.getTransform();
 631
 632                 if(antiAliasing)
 633                         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 634                             RenderingHints.VALUE_ANTIALIAS_ON);
 635
 636                 for(int i = 0; i < drawobjects.size(); i++)
 637                         {
 638                         Shape shape = (Shape)drawobjects.elementAt(i);
 639
 640                         if(shape.visible)
 641                                 {
 642                                 g2.transform(shape.transform);
 643                                 shape.drawShape(g2);
 644                                 g2.setTransform(normalTransform);
 645                                 }
 646                         }
 647
 648                 paintComponents(g2);
 649                 }
 650
 651         public Iterator getTagsFromPoint(int X, int Y)
 652                 {
 653                 HashMap tags = new HashMap();
 654                 for(int i = 0; i < drawobjects.size(); i++)
 655                         {
 656                         Shape shape = (Shape)drawobjects.elementAt(i);
 657                         if(shape.hasPoint(X, Y))
 658                                 {
 659                                 if(!tags.containsKey(shape.tag))
 660                                         tags.put(shape.tag, 0);
 661                                 }
 662                         }
 663
 664                 return tags.keySet().iterator();
 665                 }
 666
 667         public void mouseClicked(MouseEvent e)
 668                 {
 669                 if(mouseClickedEvent == null) return;
 670
 671                 int X = e.getX();
 672                 int Y = e.getY();
 673
 674                 guiserver.out.print("(" + mouseClickedEvent + " " + X + " " + Y + " " +
 675                         e.getButton() + " " + e.getClickCount() + " " + e.getModifiers());
 676
 677                 if(mouseClickedTags)
 678                         {
 679                         guiserver.out.print(" '(");
 680                         Iterator tags = getTagsFromPoint(X, Y);
 681                         while(tags.hasNext())
 682                                 guiserver.out.print("\"" + tags.next() + "\" ");
 683                         guiserver.out.print(")");
 684                         }
 685
 686                 guiserver.out.println(")");
 687                 guiserver.out.flush();
 688                 }
 689
 690         public void mouseEntered(MouseEvent e)
 691                 {
 692                 if(mouseEnteredEvent == null) return;
 693                 }
 694
 695         public void mouseExited(MouseEvent e)
 696                 {
 697                 if(mouseExitedEvent == null) return;
 698                 }
 699
 700         public void mousePressed(MouseEvent e)
 701                 {
 702                 if(mousePressedEvent == null) return;
 703
 704                 int X = e.getX();
 705                 int Y = e.getY();
 706
 707                 guiserver.out.print("(" + mousePressedEvent + " " + X + " " + Y + " " +
 708                         e.getButton() + " " + e.getModifiers());
 709
 710                 if(mousePressedTags)
 711                         {
 712                         guiserver.out.print(" '(");
 713                         Iterator tags = getTagsFromPoint(X, Y);
 714                         while(tags.hasNext())
 715                                 guiserver.out.print("\"" + tags.next() + "\" ");
 716                         guiserver.out.print(")");
 717                         }
 718
 719                 guiserver.out.println(")");
 720                 guiserver.out.flush();
 721                 }
 722
 723         public void mouseReleased(MouseEvent e)
 724                 {
 725                 if(mouseReleasedEvent == null) return;
 726
 727                 int X = e.getX();
 728                 int Y = e.getY();
 729
 730                 guiserver.out.print("(" + mouseReleasedEvent + " " + X + " " + Y + " " +
 731                         e.getButton() + " " + e.getModifiers());
 732
 733                 if(mouseReleasedTags)
 734                         {
 735                         guiserver.out.print(" '(");
 736                         Iterator tags = getTagsFromPoint(X, Y);
 737                         while(tags.hasNext())
 738                                 guiserver.out.print("\"" + tags.next() + "\" ");
 739                         guiserver.out.print(")");
 740                         }
 741
 742                 guiserver.out.println(")");
 743                 guiserver.out.flush();
 744                 }
 745
 746         public void mouseDragged(MouseEvent e)
 747                 {
 748                 if(mouseDraggedEvent == null) return;
 749
 750                 int X = e.getX();
 751                 int Y = e.getY();
 752
 753                 guiserver.out.println("(" + mouseDraggedEvent + " " + X + " " + Y + " " +
 754                                 e.getButton() + " " + e.getModifiers() + ")" );
 755                 guiserver.out.flush();
 756                 }
 757
 758         public void mouseMoved(MouseEvent e)
 759                 {
 760                 if(mouseMovedEvent == null) return;
 761
 762                 int X = e.getX();
 763                 int Y = e.getY();
 764
 765                 guiserver.out.print("(" + mouseMovedEvent + " " + X + " " + Y);
 766
 767                 if(mouseMovedTags)
 768                         {
 769                         guiserver.out.print(" '(");
 770                         Iterator tags = getTagsFromPoint(X, Y);
 771                         while(tags.hasNext())
 772                                 guiserver.out.print("\"" + tags.next() + "\" ");
 773                         guiserver.out.print(")");
 774                         }
 775
 776                 guiserver.out.println(")");
 777                 guiserver.out.flush();
 778                 }
 779
 780         public void mouseWheelMoved(MouseWheelEvent e)
 781                 {
 782                 if(mouseWheelMovedEvent == null) return;
 783
 784                 int rotation = e.getWheelRotation();
 785                 int X = e.getX();
 786                 int Y = e.getY();
 787
 788                 guiserver.out.println("(" + mouseWheelMovedEvent + " " + X + " " + Y + " " + rotation + ")" );
 789                 guiserver.out.flush();
 790                 }
 791
 792         public void export(String path, String format, int width, int height)
 793                 {
 794                 //BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
 795                 BufferedImage bufferimage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
 796
 797                 Graphics2D g2 = bufferimage.createGraphics();
 798
 799                 render(g2);
 800
 801                 try { ImageIO.write(bufferimage, format, new File(path)); }
 802                 catch (IOException ie) {
 803                                 ErrorDialog.show("Exporting", "Could not write file: " + path);
 804                                 }
 805                 }
 806
 807         public int print(Graphics graphics, PageFormat pageFormat, int pageIndex)
 808                 {
 809                 return(0);
 810                 }
 811         }
 812 }
 813
 814
 815 // eof //