projects/dwt-addons: dwtx/novocode/ishell/internal/TitleBar.d comparison

comparison dwtx/novocode/ishell/internal/TitleBar.d @ 190:df4e66472aff

novocode line endings, indention

author	Frank Benoit <benoit@tionex.de>
date	Sun, 26 Oct 2008 15:04:41 +0100
parents	71ca5bcf2307
children	c3583c6ec027

comparison

equal deleted inserted replaced

-:71ca5bcf2307
+:df4e66472aff
 * @version $Id: TitleBar.java 342 2005-07-09 20:37:13 +0000 (Sat, 09 Jul 2005) szeiger $
 */
 class TitleBar : Canvas
 {
 private static const long UPDATE_DELAY = 25;
 private static const int MINIMUM_GRAB_AREA = 2;
 private static const String ELLIPSIS = "...";
 private static const int LEFT_PADDING = 2;
 private static const int RIGHT_PADDING = 2;
 private static const int IMAGE_SIZE = 16;
 private static const int TOOL_SIZE = 14;
 private static const int TOP_PADDING = 1;
 private static const int BOTTOM_PADDING = 1;
 private int mouseDownOffsetX, mouseDownOffsetY, snapBackX, snapBackY;
 private bool cancelled;
 private /**volatile*/ long lastUpdate;
 private Timer timer;
 private TimerTask timerTask;
 private InternalShell ishell;
 private DesktopForm desktop;
 private String text;
 private Image image;
 private bool styleClose, styleMax, styleTool, styleMin;
 private Image closeImage, restoreImage, maximizeImage, minimizeImage;
 private MenuItem restoreItem, closeItem, maximizeItem;
 private Menu defaultPopup;
 private Point minGrabSize;
 private Shell shell;
 private Color gradStartColor, gradEndColor, textColor, inactiveGradStartColor, inactiveGradEndColor, inactiveTextColor;
 private Listener activateListener, deactivateListener;
 this(InternalShell parent, int style)
 {
 super(parent, checkStyle(style));
 this.timer = new Timer(true);
 this.minGrabSize = new Point(MINIMUM_GRAB_AREA, MINIMUM_GRAB_AREA);
 this.ishell = parent;
 this.desktop = cast(DesktopForm)ishell.getParent();
 this.styleClose = (style & DWT.CLOSE) !is 0;
 this.styleMax = (style & DWT.MAX) !is 0;
 this.styleMin = (style & DWT.MIN) !is 0;
 this.styleTool = (style & DWT.TOOL) !is 0;
 Display display = getDisplay();
 shell = getShell();
 gradStartColor = display.getSystemColor(DWT.COLOR_TITLE_BACKGROUND);
 gradEndColor = display.getSystemColor(DWT.COLOR_TITLE_BACKGROUND_GRADIENT);
 textColor = display.getSystemColor(DWT.COLOR_TITLE_FOREGROUND);
 inactiveGradStartColor = display.getSystemColor(DWT.COLOR_TITLE_INACTIVE_BACKGROUND);
 inactiveGradEndColor = display.getSystemColor(DWT.COLOR_TITLE_INACTIVE_BACKGROUND_GRADIENT);
 inactiveTextColor = display.getSystemColor(DWT.COLOR_TITLE_INACTIVE_FOREGROUND);
 GC gc = new GC(this);
 int imgHeight = gc.getFontMetrics().getHeight()-1;
 if(imgHeight%2 is 0) imgHeight--;
 gc.dispose();
 closeImage = createMenuImage(IMAGE_TYPE_CLOSE, imgHeight);
 restoreImage = createMenuImage(IMAGE_TYPE_RESTORE, imgHeight);
 maximizeImage = createMenuImage(IMAGE_TYPE_MAXIMIZE, imgHeight);
 minimizeImage = createMenuImage(IMAGE_TYPE_MINIMIZE, imgHeight);
 setFont(createTitleFont(getFont(), styleTool));
 defaultPopup = new Menu(this);
 restoreItem = new MenuItem(defaultPopup, DWT.PUSH);
 restoreItem.setText("&Restore");
 restoreItem.setImage(restoreImage);
 restoreItem.addListener(DWT.Selection, dgListener(&restoreListener));
 MenuItem minimizeItem = new MenuItem(defaultPopup, DWT.PUSH);
 minimizeItem.setText("Mi&nimize");
 minimizeItem.setEnabled(styleMin);
 minimizeItem.setImage(minimizeImage);
 minimizeItem.addListener(DWT.Selection, dgListener(&minimizeListener));
 maximizeItem = new MenuItem(defaultPopup, DWT.PUSH);
 maximizeItem.setText("Ma&ximize");
 maximizeItem.setImage(maximizeImage);
 maximizeItem.addListener(DWT.Selection, dgListener(&maximizeListener));
 new MenuItem(defaultPopup, DWT.SEPARATOR);
 closeItem = new MenuItem(defaultPopup, DWT.PUSH);
 closeItem.setText("&Close");
 closeItem.setEnabled(styleClose);
 closeItem.setImage(closeImage);
 closeItem.addListener(DWT.Selection, dgListener(&closeListener));
 addListener(DWT.Paint, dgListener(&onPaint));
 addListener(DWT.MouseDown, dgListener(&onMouseDown));
 addListener(DWT.MenuDetect, dgListener(&onMenuDetect));
 addListener(DWT.MouseDoubleClick, dgListener(&onMouseDoubleClick));
 addListener(DWT.MouseMove, dgListener(&onMouseMove));
 addListener(DWT.MouseUp, dgListener(&onMouseUp));
 activateListener = dgListener(&onActivateListener);
 deactivateListener = dgListener(&onDeactivateListener);
 shell.addListener(DWT.Activate, activateListener);
 shell.addListener(DWT.Deactivate, deactivateListener);
 addListener(DWT.Dispose, dgListener(&onDispose));
 }
 private void restoreListener(Event event)
 {
 ishell.setMaximized(false);
 }
 private void minimizeListener(Event event)
 {
 ishell.setMinimized(true);
 }
 private void maximizeListener(Event event)
 {
 ishell.setMaximized(true);
 }
 private void closeListener(Event event)
 {
 ishell.close();
 }
 private void onPaint(Event event)
 {
 Rectangle r = getClientArea();
 if(r.width is 0 || r.height is 0) return;
 bool active = (shell is display.getActiveShell() && ishell.isActiveShell());
 gc.fillGradientRectangle(r.x, r.y, r.width, r.height, false);
 int textLeftPadding = LEFT_PADDING;
 if(image !is null)
 {
 Rectangle imageBounds = image.getBounds();
 if(imageBounds.width > IMAGE_SIZE || imageBounds.height > IMAGE_SIZE)
 gc.drawImage(image, 0, 0, imageBounds.width, imageBounds.height, LEFT_PADDING, TOP_PADDING, IMAGE_SIZE, IMAGE_SIZE);
 else
 gc.drawImage(image, LEFT_PADDING + (IMAGE_SIZE-imageBounds.width)/2, (r.height-imageBounds.height)/2);
 textLeftPadding += IMAGE_SIZE + LEFT_PADDING;
 }
 if(text !is null && text.length() > 0)
 {
 gc.setForeground(active ? textColor : inactiveTextColor);
 String s = text;
 int availableWidth = r.width - textLeftPadding - RIGHT_PADDING;
 if(gc.textExtent(s, DWT.DRAW_TRANSPARENT).x > availableWidth)
 {
 int ellipsisWidth = gc.textExtent(ELLIPSIS, DWT.DRAW_TRANSPARENT).x;
 while(s.length() > 0)
 {
 s = s.substring(0, s.length()-1);
 if(gc.textExtent(s, DWT.DRAW_TRANSPARENT).x + ellipsisWidth <= availableWidth)
 {
 s ~= ELLIPSIS;
 break;
 }
 }
 setToolTipText(text);
 }
 else setToolTipText(null);
 if(s.length() > 0) gc.drawString(s, textLeftPadding, (r.height-gc.getFontMetrics().getHeight())/2, true);
 }
 else setToolTipText(null);
 }
 private void onMouseDown(Event event)
 {
 if(event.button is 1)
 {
 if(image !is null && event.x < LEFT_PADDING + IMAGE_SIZE)
 {
 cancelled = true;
 // left-clicking on the image always shows the default popup menu
 instrumentDefaultPopup(true);
 defaultPopup.setLocation(toDisplay(0, getSize().y));
 defaultPopup.setVisible(true);
 }
 else
 {
 mouseDownOffsetX = event.x;
 mouseDownOffsetY = event.y;
 Point p = ishell.getLocation();
 snapBackX = p.x;
 snapBackY = p.y;
 cancelled = false;
 }
 }
 else if(event.button is 3)
 {
 if((event.stateMask & DWT.BUTTON1) !is 0 && snapBackX !is Integer.MIN_VALUE && snapBackY !is Integer.MIN_VALUE)
 {
 ishell.setLocation(snapBackX, snapBackY);
 snapBackX = Integer.MIN_VALUE;
 snapBackY = Integer.MIN_VALUE;
 cancelled = true;
 }
 else
 {
 }
 }
 }
 private void onMenuDetect(Event event)
 {
 event.doit = false;
 Menu m = getMenu();
 if(m is null || m.isDisposed())
 {
 m = defaultPopup;
 instrumentDefaultPopup(false);
 }
 m.setLocation(event.x, event.y);
 m.setVisible(true);
 }
 private void onMouseDoubleClick(Event event)
 {
 if(event.button is 1)
 {
 if(image !is null && event.x < LEFT_PADDING + IMAGE_SIZE)
 {
 if(styleClose) ishell.close();
 }
 else
 {
 if(styleMax) ishell.setMaximized(!ishell.getMaximized());
 }
 cancelled = true;
 }
 }
 private void onMouseMove(Event event)
 {
 if(!cancelled && (event.stateMask & DWT.BUTTON1) !is 0 && !ishell.getMaximized())
 {
 if(timerTask !is null)
 {
 timerTask.cancel();
 timerTask = null;
 }
 long now = System.currentTimeMillis();
 if(lastUpdate + UPDATE_DELAY < now)
 {
 performMove(event);
 lastUpdate = now;
 }
 else
 {
 timerTask = new class() TimerTask
-{
-public void run()
-{
-TimerTask executingTask = this;
-event.display.asyncExec(new class() Runnable
 {
 public void run()
 {
-if(executingTask !is timerTask) return;
+TimerTask executingTask = this;
-performMove(event);
+event.display.asyncExec(new class() Runnable
-}
+{
-});
+public void run()
-}
+{
-};
+if(executingTask !is timerTask) return;
-timer.schedule(timerTask, UPDATE_DELAY);
+performMove(event);
 }
-}
+});
 }
+};
+timer.schedule(timerTask, UPDATE_DELAY);
-private void onMouseUp(Event event)
+}
-{
+}
+}
+private void onMouseUp(Event event)
+{
 if(ishell.getMaximized()) return;
 if(image is null || event.x >= LEFT_PADDING + IMAGE_SIZE)
 {
 if(timerTask !is null)
 {
 timerTask.cancel();
 timerTask = null;
 }
 if(!cancelled && (event.stateMask & DWT.BUTTON1) !is 0)
 {
 performMove(event);
 }
 }
 }
 private void onActivateListener(Event event)
 {
 redraw();
 }
 private void onDeactivateListener(Event event)
 {
 redraw();
 }
 private void onDispose(Event event)
 {
 timer.cancel();
 shell.removeListener(DWT.Activate, activateListener);
 shell.removeListener(DWT.Deactivate, deactivateListener);
 closeImage.dispose();
 maximizeImage.dispose();
 restoreImage.dispose();
 minimizeImage.dispose();
 defaultPopup.dispose();
 }
 private void performMove(Event event)
 {
 Point p = ishell.getLocation();
 int newX = p.x + event.x - mouseDownOffsetX;
 int newY = p.y + event.y - mouseDownOffsetY;
 // Make sure that the minimum grab area stays visible
 Rectangle deskCA = desktop.getClientArea();
 Rectangle bounds = getBounds();
 newX = Math.min(Math.max(newX, deskCA.x-bounds.x-bounds.width+MINIMUM_GRAB_AREA), deskCA.x-bounds.x+deskCA.width-minGrabSize.x);
 newY = Math.min(Math.max(newY, deskCA.y-bounds.y-bounds.height+MINIMUM_GRAB_AREA), deskCA.y-bounds.y+deskCA.height-MINIMUM_GRAB_AREA);
 if(newX !is p.x || newY !is p.y) ishell.setLocation(newX, newY);
 }
 public Point getMinGrabSize()
 {
 return minGrabSize;
 }
 public Point computeSize(int wHint, int hHint, bool changed)
 {
 checkWidget();
 if(wHint is DWT.DEFAULT) wHint = 50;
 if(hHint is DWT.DEFAULT)
 {
 GC gc = new GC(this);
 hHint = gc.getFontMetrics().getHeight();
 hHint = Math.max(hHint, styleTool ?  TOOL_SIZE : IMAGE_SIZE);
 hHint += TOP_PADDING + BOTTOM_PADDING;
 gc.dispose();
 }
 return new Point(wHint, hHint);
 }
 private static int checkStyle(int style)
 {
 //int mask = DWT.SHADOW_IN | DWT.FLAT;
 //style &= mask;
 style = DWT.NO_FOCUS;
 return style;
 }
 public bool setFocus()
 {
 checkWidget();
 return false;
 }
 public bool isReparentable ()
 {
 checkWidget();
 return false;
 }
 public void setText(String text)
 {
 checkWidget();
 this.text = text;
 redraw();
 }
 public String getText() { return text; }
 public void setImage(Image image)
 {
 checkWidget();
 if(styleTool) return;
 this.image = image;
 minGrabSize.x = MINIMUM_GRAB_AREA;
 if(image !is null) minGrabSize.x += LEFT_PADDING + IMAGE_SIZE;
 redraw();
 }
 public Image getImage() { return image; }
 private Font createTitleFont(Font f, bool tool)
 {
 FontData[] fds = f.getFontData();
 foreach(fd; fds)
 {
 fd.setStyle(fd.getStyle() | DWT.BOLD);
 if(tool) fd.setHeight(cast(int)(fd.getHeight()*0.9));
 }
 return new Font(getDisplay(), fds);
 }
 private void instrumentDefaultPopup(bool onImage)
 {
 restoreItem.setEnabled(styleMax && ishell.getMaximized());
 maximizeItem.setEnabled(styleMax && !ishell.getMaximized());
 MenuItem def = null;
 if(onImage)
 {
 if(styleClose) def = closeItem;
 }
 else if(styleMax)
 {
 def = ishell.getMaximized() ? restoreItem : maximizeItem;
 }
 defaultPopup.setDefaultItem(def);
 }
 private static const int IMAGE_TYPE_CLOSE    = 1;
 private static const int IMAGE_TYPE_MAXIMIZE = 2;
 private static const int IMAGE_TYPE_RESTORE  = 3;
 private static const int IMAGE_TYPE_MINIMIZE = 4;
 private Image createMenuImage(int type, int height)
 {
 final Point size = new Point(height, height);
 final int imgWidth = height + height/2;
 final Color fg = getForeground();
 final Color white = getDisplay().getSystemColor(DWT.COLOR_WHITE);
 final RGB blackRGB = new RGB(0,0,0);
 ImageData id = new ImageData(imgWidth, size.y, 1, new PaletteData([ blackRGB, fg.getRGB() ]));
 ImageData maskid = new ImageData(imgWidth, size.y, 1, new PaletteData([ blackRGB, white.getRGB() ]));
 Image img = new Image(getDisplay(), id);
 GC gc = new GC(img);
 gc.setForeground(fg);
 drawMenuImage(gc, size, type);
 gc.dispose();
 Image maskimg = new Image(getDisplay(), maskid);
 gc = new GC(maskimg);
 gc.setForeground(white);
 drawMenuImage(gc, size, type);
 gc.dispose();
 Image transp = new Image(getDisplay(), img.getImageData(), maskimg.getImageData());
 img.dispose();
 maskimg.dispose();
 return transp;
 }
 private void drawMenuImage(GC gc, Point size, int type)
 {
 switch(type)
 {
 case IMAGE_TYPE_CLOSE:
 gc.drawLine(1, 1, size.x-2, size.y-2);
 gc.drawLine(2, 1, size.x-2, size.y-3);
 gc.drawLine(1, 2, size.x-3, size.y-2);
 gc.drawLine(1, size.y-2, size.x-2, 1);
 gc.drawLine(1, size.y-3, size.x-3, 1);
 gc.drawLine(2, size.y-2, size.x-2, 2);
 break;
 case IMAGE_TYPE_RESTORE:
 gc.drawRectangle(0, 4, size.x-4, size.y-6);
 gc.drawLine(1, 5, size.x-5, 5);
 gc.drawLine(2, 1, size.x-2, 1);
 gc.drawLine(2, 2, size.x-2, 2);
 gc.drawPoint(2, 3);
 gc.drawLine(size.x-2, 3, size.x-2, size.y-5);
 gc.drawPoint(size.x-3, size.y-5);
 break;
 case IMAGE_TYPE_MAXIMIZE:
 gc.drawRectangle(0, 0, size.x-2, size.y-2);
 gc.drawLine(1, 1, size.x-3, 1);
 break;
 case IMAGE_TYPE_MINIMIZE:
 gc.drawLine(1, size.y-2, size.x-4, size.y-2);
 gc.drawLine(1, size.y-3, size.x-4, size.y-3);
 break;
 }
 }
 }

Mercurial > projects > dwt-addons

comparison dwtx/novocode/ishell/internal/TitleBar.d @ 190:df4e66472aff