/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * CosyBeans-Common is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import java.awt.BorderLayout;
  import java.awt.CardLayout;
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Point;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.ItemEvent;
  import java.awt.event.ItemListener;
  import java.awt.event.KeyEvent;
  import java.awt.event.KeyListener;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseListener;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  import java.text.DateFormatSymbols;
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.GregorianCalendar;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.swing.DefaultComboBoxModel;
  import javax.swing.JComboBox;
  import javax.swing.JComponent;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JList;
  import javax.swing.JMenuItem;
  import javax.swing.JPanel;
  import javax.swing.JPopupMenu;
  import javax.swing.ListCellRenderer;
  import javax.swing.SwingUtilities;
  import javax.swing.border.LineBorder;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.plaf.basic.BasicComboBoxEditor;
  
  
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyUIElements;
  import com.cosylab.gui.components.util.PaintHelper;
  import com.cosylab.util.DateSpan;
  
  
  /**
   * A simple graphical widget for selecting date intervals.  The component
   * consists of a <code>SimpleComboBox</code> containing months and years and
   * a panel of labels indicating days in the selected month. The user can
   * select date intervals by dragging the mouse over the chosen set of date
   * labels.  Selections of spanning over multiple months are possible by
   * dragging the mouse outside the date panel area in the chosen direction.
   * <p>
   * When a date is selected PropertyChangeListeners are notified through the
   * property <code>selectedDateSpan</code>. The new value indicates the current
   * date selection. Date is always selected from the midnight of the beginning
   * date till the end of the ending date.
   * </p> 
   *
   * @author <a href="mailto:jernej.kamenik@cosylab.com">Jernej Kamenik</a>
   * @version $id$
   */
  public class DateSpanSelector extends JPanel
  {
  	private static final long serialVersionUID = -501052522043801432L;
  	private static final Color EXTENDED_SELECTION_COLOR = Color.red;
  
  	private class YearButton extends ArrowButton {
 
 		private static final long serialVersionUID = -6687714559622460070L;
 		private int orientation;
 		public YearButton(int orientation){
 			super(orientation);
 			this.orientation = orientation;
 		}
 		@Override
 		public void paintComponent(Graphics g) {
 			((Graphics2D)g).addRenderingHints(PaintHelper.getAntialiasingHints());
 			super.paintComponent(g);
 
 			int maxHeight = getBounds().height;
 			int maxWidth = getBounds().width;
 			int top=1;
 			int bottom=1;
 			int left=1;
 			int right=1;
 			top = Math.min(maxWidth, maxHeight) / 4;
 			bottom = Math.min(maxWidth, maxHeight) / 4;
 			left = Math.min(maxWidth, maxHeight) / 4;
 			right = Math.min(maxWidth, maxHeight) / 4;
 
 			g.setColor(getForeground());
 			if (orientation == RIGHT) {
 				int middle = 2*(maxWidth - right)/3;
 				middle = left+(maxWidth-right-left)/2;
 				int[] ys = { top, maxHeight / 2, maxHeight / 2, top, maxHeight / 2, maxHeight - bottom, maxHeight / 2,maxHeight / 2,  maxHeight - bottom};
 				int[] xs = { left, middle, middle, middle, maxWidth-right, middle, middle, middle, left };
 				g.fillPolygon(xs, ys, 9);
 			} else if (orientation == LEFT) {
 				
 				int middle = 2*(maxWidth - right)/3;
 				middle = left+(maxWidth-right-left)/2;
 				int[] ys = { top, maxHeight / 2, maxHeight / 2, top, maxHeight / 2, maxHeight - bottom, maxHeight / 2,maxHeight / 2,  maxHeight - bottom};
 				int[] xs = { maxWidth-right, middle, middle, middle, left, middle, middle, middle, maxWidth-right };
 				g.fillPolygon(xs, ys, 9);
 			}
 			
 		}		
 	}
 	
 	/* A container for date labels of one month,
 	 * also manages all user actions.
 	 */
 	private class DatePanel extends JComponent implements ItemListener,
 		MouseListener, KeyListener
 	{
 		private static final long serialVersionUID = 3649761076701751548L;
 
 		/* A simple extension of com.cosylab.gui.components.JResizableLabel
 		 * designed for storing dates.
 		 */
 		private class DateCell extends ResizableTextLabel
 		{
 			private static final long serialVersionUID = -6558819543510561495L;
 			private int date;
 			private boolean adjustFont;
 			private boolean paintForward;
 			private boolean paintBackward;
 
 			/**
 			 * Constructor for DateCell
 			 */
 			public DateCell()
 			{
 				super("  ");
 				setResizable(true);
 				setColumns(2);
 				setOpaque(true);
 				setHorizontalAlignment(JLabel.CENTER);
 				setMinimumSize(new Dimension(30, 10));
 				setEnhanced(true);
 				setFocusable(true);
 			}
 
 			/**
 			 * Sets the day in the month to the date cell.
 			 *
 			 * @param newDate int
 			 *
 			 * @throws IllegalArgumentException if date value is less then 1 or
 			 *         more than 31
 			 */
 			public void setDate(int newDate)
 			{
 				if ((newDate < 1) || (newDate > 31)) {
 					throw new IllegalArgumentException(
 					    "Date value out of bounds: " + newDate);
 				}
 
 				date = newDate;
 
 				if (newDate < 10) {
 					setText(" " + String.valueOf(newDate));
 				} else {
 					setText(String.valueOf(newDate));
 				}
 			}
 
 			/**
 			 * Returns the day in the month stored in the date cell.
 			 *
 			 * @return int the number of the day in the month.
 			 */
 			public int getDate()
 			{
 				return date;
 			}
 			protected void resize()
 			{
 				if (adjustFont){
 					super.resize();
 					unifyFontSize();
 				}
 			}
 
 			public boolean isAdjustFont() {
 				return adjustFont;
 			}
 
 			public void setAdjustFont(boolean adjustFont) {
 				this.adjustFont = adjustFont;
 			}
 
 			@Override
 			protected void paintComponent(Graphics g) {
 				super.paintComponent(g);
 				// painting symbols for extended selection
 				//int maxHeight = getBounds().height;
 				//int maxWidth = getBounds().width;
 				//smaller arrows
 				/*if (isPaintBackward()){
 					int refX = 3*maxWidth/4;
 					int refY = 3*maxHeight/4;
 					int[] ys = { refY, refY+(maxHeight-refY)/2, maxHeight};
 					int[] xs = { refX, maxWidth, refX};
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}
 				else if (isPaintForward()){
 					int[] ys = { 0, maxHeight/4, maxHeight/8  };
 					int[] xs = { maxWidth/4, maxWidth/4, 0 };
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}*/
 				//larger arrows
 				/*if (isPaintBackward()){
 					int refX = 0;
 					int refY = 0;
 					int[] ys = { refY, refY+(maxHeight-refY)/2, maxHeight};
 					int[] xs = { refX, maxWidth, refX};
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}
 				else if (isPaintForward()){
 					int[] ys = { 0, maxHeight, maxHeight/2  };
 					int[] xs = { maxWidth, maxWidth, 0 };
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}*/
 				
 				//slim arrows
 				
 				int maxHeight = getBounds().height;
 				int maxWidth = getBounds().width/4;
 				
 				if ((isPaintForward())){
 					int refX = (3*getBounds().width)/4;
 					int refY = 0;
 					int[] ys = { refY, refY+(maxHeight-refY)/2, refY+maxHeight};
 					int[] xs = { refX, refX+maxWidth, refX};
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}
 				else if (isPaintBackward()){
 					int refX = 0;
 					int refY = 0;
 					int[] ys = {refY+0, refY+maxHeight, refY+maxHeight/2  };
 					int[] xs = {refX+maxWidth, refX+maxWidth, refX+0 };
 					g.setColor(EXTENDED_SELECTION_COLOR);
 					g.fillPolygon(xs, ys, 3);
 				}				
 			}
 
 			public boolean isPaintForward() {
 				return paintForward;
 			}
 
 			public void setPaintForward(boolean paintForward) {
 				this.paintForward = paintForward;
 			}
 
 			public boolean isPaintBackward() {
 				return paintBackward;
 			}
 
 			public void setPaintBackward(boolean paintBackward) {
 				this.paintBackward = paintBackward;
 			}
 		}
 		private class DayNameCell extends ResizableTextLabel
 		{
 			private static final long serialVersionUID = -6558819541235431495L;
 			private boolean adjustFont;
 
 			public DayNameCell(String string) {
 				super(string);
 			}
 
 			protected void resize()
 			{
 				if (adjustFont){
 					super.resize();
 					unifyFontSize();
 				}
 			}
 
 			public boolean isAdjustFont() {
 				return adjustFont;
 			}
 
 			public void setAdjustFont(boolean adjustFont) {
 				this.adjustFont = adjustFont;
 			}
 		}		
 
 		private Calendar currentDate;
 		private Calendar displayMonthDate;
 		private Calendar selectionFinishDate;
 		private Calendar selectionStartDate;
 		//private Color dayNameBackground = ColorHelper.getControlShadow();
 		//changed as per request 36667
 		private Color dayNameBackground = new Color(218,226,234);
 		
 		private Color dayNameForeground = ColorHelper.getControlDarkShadow();//ColorHelper.getControlHighlight();
 		private Color othersForeground = ColorHelper.getControlDarkShadow();
 		//private Color sundayBackground = ColorHelper.getControlShadow();
 		private Color sundayBackground = new Color(218,226,234);
 		private Color sundayForeground = ColorHelper.getControlText();
 		private Color sundaySelection = ColorHelper.getCosyControlShadow();
 		private List<DateCell> dateCells;
 		private List<DayNameCell> dayNameCells;
 		
 		private Timer switchTimer = null;
 		private boolean selecting;
 		private int switching;
 
 		/**
 		 * Constructor for DatePanel
 		 */
 		public DatePanel()
 		{
 			super();
 			setBackground(ColorHelper.getWindowBackground());
 			currentDate = GregorianCalendar.getInstance();
 			displayMonthDate = GregorianCalendar.getInstance();
 			displayMonthDate.set(Calendar.DATE, 15);
 			normalizeToMiddleOfDay(displayMonthDate);
 			populateDateList();
 			pupulateDayNamesList();
 			init();
 		}
 
 		private void pupulateDayNamesList() {
 			if (dayNameCells == null) {
 				dayNameCells = new ArrayList<DayNameCell>();
 			}
 			DayNameCell dateLabel = null;
 			for (int i = 0; i < 7; i++) {
 				dateLabel = new DayNameCell(DAYS[i]);
 				if (i==0) dateLabel.setAdjustFont(true); 
 				dateLabel.setOpaque(true);
 				dateLabel.setBackground(dayNameBackground);
 				dateLabel.setForeground(dayNameForeground);
 				dateLabel.setResizable(true);
 				dateLabel.setColumns(3);
 				dateLabel.setHorizontalAlignment(JLabel.CENTER);
 				Font f = dateLabel.getFont();
 				dateLabel.setFont(f.deriveFont(f.getStyle() ^ Font.BOLD));
 				dayNameCells.add(dateLabel);
 			}
 			
 		}
 
 		/**
 		 * Performs initialization of the DatePanel.
 		 */
 		public void init()
 		{
 			removeAll();
 			setLayout(new CosyUIElements.FillingGridLayout(0, 7));
 			setOpaque(true);
 
 			
 
 			for (int i = 0; i < 7; i++) {
 				add(dayNameCells.get(i));
 			}
 
 
 			for (int i = 0; i < 42; i++) {
 				add(dateCells.get(i));
 			}
 		}
 
 		/**
 		 * Invoked when a different month was selected in MonthCombo that
 		 * should be displayed
 		 *
 		 * @param e ListSelectionEvent
 		 *
 		 * @see javax.swing.event.ListSelectionListener#valueChanged(ListSelectionEvent)
 		 */
 		public void itemStateChanged(ItemEvent e)
 		{
 			Calendar monthDate = (Calendar)((JComboBox)e.getSource())
 				.getSelectedItem();
 
 			if ((displayMonthDate.get(Calendar.YEAR) == monthDate.get(
 			        Calendar.YEAR))
 			    && (displayMonthDate.get(Calendar.MONTH) == monthDate.get(
 			        Calendar.MONTH))) {
 				return;
 			}
 
 			displayMonthDate.set(Calendar.YEAR, monthDate.get(Calendar.YEAR));
 			displayMonthDate.set(Calendar.MONTH, monthDate.get(Calendar.MONTH));
 
 			if (selecting) {
 				ensureSelection();
 				selectionFinishDate.set(Calendar.YEAR,
 				    monthDate.get(Calendar.YEAR));
 				selectionFinishDate.set(Calendar.MONTH,
 				    monthDate.get(Calendar.MONTH));
 			}
 
 			populateDateList();
 		}
 
 		/* (non-Javadoc)
 		 * @see java.awt.event.KeyListener#keyPressed(java.awt.event.KeyEvent)
 		 */
 		public void keyPressed(KeyEvent e)
 		{
 			if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
 				selecting = true;
 
 				return;
 			}
 
 			int date = ((DateCell)e.getSource()).getDate();
 
 			if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
 				displayMonthDate = Calendar.getInstance();
 				normalizeToMiddleOfDay(displayMonthDate);
 				date = displayMonthDate.get(Calendar.DAY_OF_MONTH);
 			} else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
 				date++;
 			} else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
 				date--;
 			} else if (e.getKeyCode() == KeyEvent.VK_UP) {
 				date -= 7;
 			} else if (e.getKeyCode() == KeyEvent.VK_DOWN) {
 				date += 7;
 			} else {
 				return;
 			}
 
 			if (date > displayMonthDate.getActualMaximum(Calendar.DAY_OF_MONTH)) {
 				date = date
 					- displayMonthDate.getActualMaximum(Calendar.DAY_OF_MONTH);
 				displayMonthDate.add(Calendar.MONTH, 1);
 			} else if (date < 1) {
 				displayMonthDate.add(Calendar.MONTH, -1);
 				date = displayMonthDate.getActualMaximum(Calendar.DAY_OF_MONTH)
 					+ date;
 			}
 
 			if ((e.getModifiersEx() & KeyEvent.SHIFT_DOWN_MASK) == KeyEvent.SHIFT_DOWN_MASK) {
 				ensureSelection();
 				selectionFinishDate.set(displayMonthDate.get(Calendar.YEAR),
 				    displayMonthDate.get(Calendar.MONTH), date);
 			} else {
 				ensureSelection();
 				selectionStartDate.set(displayMonthDate.get(Calendar.YEAR),
 				    displayMonthDate.get(Calendar.MONTH), date);
 				selectionFinishDate.set(displayMonthDate.get(Calendar.YEAR),
 				    displayMonthDate.get(Calendar.MONTH), date);
 
 				selectionStopped();
 			}
 
 			Calendar datec = createCopy(displayMonthDate);
 			datec.set(Calendar.DAY_OF_MONTH, 1);
 			normalizeToBeginningOfDay(datec);
 			monthCombo.setSelectedItem(datec);
 
 			populateDateList();
 		}
 
 		/* (non-Javadoc)
 		 * @see java.awt.event.KeyListener#keyReleased(java.awt.event.KeyEvent)
 		 */
 		public void keyReleased(KeyEvent arg0)
 		{
 			if (arg0.getKeyCode() == KeyEvent.VK_SHIFT) {
 				selectionStopped();
 			}
 		}
 
 		/* (non-Javadoc)
 		 * @see java.awt.event.KeyListener#keyTyped(java.awt.event.KeyEvent)
 		 */
 		public void keyTyped(KeyEvent arg0)
 		{
 		}
 
 		/**
 		 * Invoked when the user clicks the mouse inside  one of the date
 		 * cells. The cell is selected and the starting and finishing date
 		 * selections are set to the same date.
 		 *
 		 * @param e MouseEvent
 		 *
 		 * @see java.awt.event.MouseListener#mouseClicked(MouseEvent)
 		 */
 		public void mouseClicked(MouseEvent e)
 		{	
 			if (e.getButton()== MouseEvent.BUTTON3){
 				getPopup().show(e.getComponent(),
 	                       e.getX(), e.getY());
 				return;
 			}
 			if (!this.isEnabled()) return;
 			int date = ((DateCell)e.getSource()).getDate();
 			int monthOffset = 0;
 
 			if ((date < 15) && !((DateCell)e.getSource()).isEnabled()) {
 				monthOffset++;
 			} else if ((date > 15) && !((DateCell)e.getSource()).isEnabled()) {
 				monthOffset--;
 			}
 
 			ensureSelection();
 			selectionStartDate.set(displayMonthDate.get(Calendar.YEAR),
 			    displayMonthDate.get(Calendar.MONTH) + monthOffset, date);
 			selectionFinishDate.set(displayMonthDate.get(Calendar.YEAR),
 			    displayMonthDate.get(Calendar.MONTH) + monthOffset, date);
 
 			selectionStopped();
 			populateDateList();
 		}
 
 		/**
 		 * Used during the date span selection procedure.
 		 *
 		 * @param e MouseEvent
 		 *
 		 * @see java.awt.event.MouseListener#mouseEntered(MouseEvent)
 		 */
 		public void mouseEntered(MouseEvent e)
 		{
 			if (switching != 0) {
 				switchTimer.cancel();
 				switching = 0;
 			}
 
 			if (selecting) {
 				int date = ((DateCell)e.getSource()).getDate();
 				int monthOffset = 0;
 
 				if ((date < 15) && !((DateCell)e.getSource()).isEnabled()) {
 					monthOffset++;
 				} else if ((date > 15)
 				    && !((DateCell)e.getSource()).isEnabled()) {
 					monthOffset--;
 				}
 
 				ensureSelection();
 				selectionFinishDate.set(displayMonthDate.get(Calendar.YEAR),
 				    displayMonthDate.get(Calendar.MONTH) + monthOffset, date,
 				    12, 0, 0);
 				populateDateList();
 			}
 		}
 
 		/**
 		 * Used during the date span selection procedure for switching between
 		 * selected months when the user drags the mouse outside the date
 		 * panel.
 		 *
 		 * @param e MouseEvent
 		 *
 		 * @see java.awt.event.MouseListener#mouseExited(MouseEvent)
 		 */
 		public void mouseExited(MouseEvent e)
 		{
 			if (selecting) {
 				Component eventSource = (Component)e.getSource();
 				Point eventPoint = e.getPoint();
 				int offset = eventSource.getWidth() + 1;
 				eventPoint = SwingUtilities.convertPoint(eventSource,
 					    eventPoint, this);
 
 				if (eventPoint.x >= ((getLocation().x + getWidth()) - offset)) {
 					switching = 1;
 				} else if (eventPoint.x <= (getLocation().x + offset)) {
 					switching = -1;
 				}
 
 				if (switching != 0) {
 					switchTimer = new Timer();
 					switchTimer.schedule(new TimerTask() {
 							public void run()
 							{
 								if (selecting && (switching != 0)) {
 									switchMonths();
 								}
 							}
 
 							private void switchMonths()
 							{
 								displayMonthDate.add(Calendar.MONTH, switching);
 								ensureSelection();
 								selectionFinishDate.add(Calendar.MONTH,
 								    switching);
 								populateDateList();
 
 								Calendar date = createCopy(displayMonthDate);
 								date.set(Calendar.DAY_OF_MONTH, 1);
 								normalizeToBeginningOfDay(date);
 								monthCombo.setSelectedItem(date);
 								monthCombo.repaint();
 							}
 						}, 300, 400);
 				}
 			}
 		}
 
 		/**
 		 * Invoked when the user presses the mouse button in one of the date
 		 * cells. The date span selection procedure is started.
 		 *
 		 * @param e MouseEvent
 		 *
 		 * @see java.awt.event.MouseListener#mousePressed(MouseEvent)
 		 */
 		public void mousePressed(MouseEvent e)
 		{
 			if (e.getButton()== MouseEvent.BUTTON3){
 				return;
 			}
 			if (!this.isEnabled()) return;
 			selecting = true;
 
 			int date = ((DateCell)e.getSource()).getDate();
 			int monthOffset = 0;
 
 			if ((date < 15) && !((DateCell)e.getSource()).isEnabled()) {
 				monthOffset++;
 			} else if ((date > 15) && !((DateCell)e.getSource()).isEnabled()) {
 				monthOffset--;
 			}
 
 			ensureSelection();
 			selectionStartDate.set(displayMonthDate.get(Calendar.YEAR),
 			    displayMonthDate.get(Calendar.MONTH) + monthOffset, date);
 			selectionFinishDate.set(displayMonthDate.get(Calendar.YEAR),
 			    displayMonthDate.get(Calendar.MONTH) + monthOffset, date);
 
 			populateDateList();
 		}
 
 		/**
 		 * Invoked when the user releases the mouse  on one of the date cells.
 		 * The date span  selection procedure is completed and a new selected
 		 * date span is set.
 		 *
 		 * @param e MouseEvent
 		 *
 		 * @see java.awt.event.MouseListener#mouseReleased(MouseEvent)
 		 */
 		public void mouseReleased(MouseEvent e)
 		{
 			if (e.getButton()== MouseEvent.BUTTON3){
 				return;
 			}
 			if (!this.isEnabled()) return;
 			selectionStopped();
 		}
 
 		private void populateDateList()
 		{
 			currentDate = GregorianCalendar.getInstance();
 			DateCell dateCell = null;
 
 			if (dateCells == null) {
 				dateCells = new ArrayList<DateCell>();
 
 				for (int i = 0; i < 42; i++) {
 					dateCell = new DateCell();
 					if (i==0) dateCell.setAdjustFont(true); 
 					dateCell.addMouseListener(this);
 					dateCell.addKeyListener(this);
 					dateCells.add(dateCell);
 				}
 			}
 
 			int dayInMonth = displayMonthDate.get(Calendar.DAY_OF_MONTH);
 			displayMonthDate.add(Calendar.DATE, 1 - dayInMonth);
 
 			int firstDayOfMonth = displayMonthDate.get(Calendar.DAY_OF_WEEK)
 				- 2;
 			
 			if (firstDayOfMonth < 0) {
 				firstDayOfMonth += 7;
 			}
 
 			int lastDayOfMonth = (firstDayOfMonth
 				+ displayMonthDate.getActualMaximum(Calendar.DAY_OF_MONTH)) - 1;
 			displayMonthDate.add(Calendar.DATE, -firstDayOfMonth);
 			for (int i = 0; i < 42; i++) {
 				dateCell = dateCells.get(i);
 				dateCell.setEnabled(true);
 				dateCell.setDate(displayMonthDate.get(Calendar.DAY_OF_MONTH));
 
 				if ((i < firstDayOfMonth) || (i > lastDayOfMonth)) {
 					dateCell.setForeground(othersForeground);
 					dateCell.setEnabled(false);
 				} else {
 					dateCell.setForeground(getForeground());
 				}
 
 				if (displayMonthDate.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
 					dateCell.setBackground(sundayBackground);
 					dateCell.setForeground(sundayForeground);
 				} else {
 					dateCell.setBackground(getBackground());
 				}
 
 				if ((displayMonthDate.get(Calendar.YEAR) == currentDate.get(
 				        Calendar.YEAR))
 				    && (displayMonthDate.get(Calendar.MONTH) == currentDate.get(
 				        Calendar.MONTH))
 				    && (displayMonthDate.get(Calendar.DATE) == currentDate.get(
 				        Calendar.DATE))) {
 					dateCell.setBorder(new LineBorder(Color.BLACK));
 				} else {
 					dateCell.setBorder(null);
 				}
 
 				if (selectionFinishDate!=null && selectionStartDate!=null && (((displayMonthDate.getTimeInMillis() >= selectionStartDate
 				    .getTimeInMillis())
 				    && (displayMonthDate.getTimeInMillis() <= selectionFinishDate
 				    .getTimeInMillis()))
 				    || ((displayMonthDate.getTimeInMillis() <= selectionStartDate
 				    .getTimeInMillis())
 				    && (displayMonthDate.getTimeInMillis() >= selectionFinishDate
 				    .getTimeInMillis())))) {
 					if (displayMonthDate.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
 						dateCell.setBackground(sundaySelection);
 					} else {
 						dateCell.setBackground(ColorHelper.getTextHighlight());
 					}
 				}
 				
 				if (displayMonthDate.equals(selectionFinishDate)) {
 					if (!monthCombo.isPopupVisible()) {
 						dateCell.requestFocusInWindow();
 					}
 				}
 
 				// painting the symbols for selection extending in next/previous month
 				if (selectionFinishDate!=null && selectionStartDate!=null){
 					
 					
 					if (i==41 
 						&& selectionStartDate.getTimeInMillis()<=displayMonthDate.getTimeInMillis()
 						&& selectionFinishDate.getTimeInMillis()>displayMonthDate.getTimeInMillis()){
 							dateCell.setPaintForward(true);
 					} else 
 							dateCell.setPaintForward(false);
 					if (i==0 
 							&& selectionStartDate.getTimeInMillis()<displayMonthDate.getTimeInMillis()
 							&& selectionFinishDate.getTimeInMillis()>=displayMonthDate.getTimeInMillis()){
 							dateCell.setPaintBackward(true);
 					} else 
 							dateCell.setPaintBackward(false);
 				} 
 						
 				
 				displayMonthDate.add(Calendar.DATE, 1);
 			}
 
 			displayMonthDate.add(Calendar.DATE,
 			    (firstDayOfMonth + dayInMonth) - 1 - 42);
 		}
 
 
 
 		private void selectionStopped()
 		{
 			selecting = false;
 
 			Calendar start = null;
 			Calendar finish = null;
 
 			ensureSelection();
 			if (selectionStartDate.getTimeInMillis() <= selectionFinishDate
 			    .getTimeInMillis()) {
 				start = createCopy(selectionStartDate);
 				finish = createCopy(selectionFinishDate);
 			} else {
 				start = createCopy(selectionFinishDate);
 				finish = createCopy(selectionStartDate);
 			}
 
 			normalizeToBeginningOfDay(start);
 			normalizeToEndOfDay(finish);
 			setSelectedDateSpan(new DateSpan(start.getTime(), finish.getTime()));
 		}
 
 		private void clearSelection() {
 			selectionStartDate=null;
 			selectionFinishDate=null;
 		}
 
 		private void ensureSelection() {
 			if (selectionStartDate==null) {
 				selectionStartDate = GregorianCalendar.getInstance();
 				normalizeToMiddleOfDay(selectionStartDate);
 			}
 			
 			if (selectionFinishDate==null) {
 				selectionFinishDate = GregorianCalendar.getInstance();
 				normalizeToMiddleOfDay(selectionFinishDate);
 			}
 		}
 
 		@Override
 		public void setEnabled(boolean enabled) {
 			super.setEnabled(enabled);
 			for (Iterator<DateCell> iterator = dateCells.iterator(); iterator.hasNext();) {
 				DateCell cell = iterator.next();
 				cell.setEnabled(enabled);
 				
 			}
 		}
 
 		protected void unifyFontSize() {
 			if (dayNameCells == null || dateCells == null) return;
 			
 			// unify the text size for day name cells
 			Font fn= null;
 			for (Iterator<DayNameCell> iterator = dayNameCells.iterator(); iterator.hasNext();) {
 				DayNameCell cell = iterator.next();
 				if (fn==null)fn=cell.getFont();
 				cell.setFont(fn);
 			}			
 			// unify the text size for date cells
 			Font fd = null;
 			for (Iterator<DateCell> iterator = dateCells.iterator(); iterator.hasNext();) {
 				DateCell cell = iterator.next();
 				if (fd==null)fd=cell.getFont();
 				cell.setFont(fd);
 			}
 			
 		}
 	}
 
 	/*
 	 * A simple extension of com.cosylab.gui.components.SimpleComboBox
 	 * for selecting months in years between 1950 and 2050
 	 */
 	private class MonthCombo extends SimpleComboBox
 	{
 		
 		private static final long serialVersionUID = -848887269904982102L;
 		/*
 		 * Renderer for MONTH and YEAR fields od java.util.Calendar objects.
 		 */
 		private class MonthCellRenderer extends JLabel
 			implements ListCellRenderer
 		{
 			private static final long serialVersionUID = -7240298232411247122L;
 
 			/**
 			 * Constructor for MonthCellRenderer.
 			 */
 			public MonthCellRenderer()
 			{
 				super();
 				setHorizontalAlignment(JLabel.CENTER);
 				setOpaque(true);
 				setEditor(new BasicComboBoxEditor());
 			}
 
 			/**
 			 * Returns the rendered cell.
 			 *
 			 * @param list JList
 			 * @param value Object
 			 * @param index int
 			 * @param isSelected boolean
 			 * @param cellHasFocus boolean
 			 *
 			 * @return Component
 			 *
 			 * @see javax.swing.ListCellRenderer#getListCellRendererComponent(JList,
 			 *      Object, int, boolean, boolean)
 			 */
 			public Component getListCellRendererComponent(JList list,
 			    Object value, int index, boolean isSelected,
 			    boolean cellHasFocus)
 			{
 				if (isSelected) {
 					setBackground(ColorHelper.getControl());
 				} else {
 					setBackground(ColorHelper.getControlHighlight());
 				}
 
 				Calendar date = (Calendar)value;
 				String name = MONTHS[date.get(Calendar.MONTH)] + " "
 					+ date.get(Calendar.YEAR);
 				setText(name);
 				return this;
 			}
 		}
 
 		/**
 		 * Constructor for MonthCombo.
 		 */
 		public MonthCombo()
 		{
 			super();
 			setStyle(Style.SWITCH_STYLE_POPUP_ENABLED);
 			setMaximumRowCount(12);
 			setRenderer(new MonthCellRenderer());
 			setBorder(null);
 			populateMonthList();
 			addMouseListener(new MouseListener(){
 				public void mouseClicked(MouseEvent e) {
 					if (e.getButton()==MouseEvent.BUTTON3){
 						getPopup().show(e.getComponent(),
 			                       e.getX(), e.getY());
 					}										
 				}
 				public void mouseEntered(MouseEvent e) {
 				}
 				public void mouseExited(MouseEvent e) {
 				}
 				public void mousePressed(MouseEvent e) {					
 				}
 				public void mouseReleased(MouseEvent e) {
 					
 				}});
 		}
 
 		private void populateMonthList()
 		{
 			for (int i = 1950; i <= 2050; i++) {
 				for (int j = 1; j <= 12; j++) {
 					((DefaultComboBoxModel)getModel()).addElement(new GregorianCalendar(
 					        i, j, 1));
 				}
 			}
 
 			Calendar date = Calendar.getInstance();
 			date.set(Calendar.DAY_OF_MONTH, 1);
 			normalizeToBeginningOfDay(date);
 			setSelectedItem(date);
 		}
 	}
 
 	/** Names of week days. */
 	public static final String[] DAYS; 
 	/** Names of months. */
 	public static final String[] MONTHS; 
 	
 	static {
 		String[] data = new DateFormatSymbols().getShortWeekdays();
 		DAYS = new String[]{data[Calendar.MONDAY],data[Calendar.TUESDAY],
 				data[Calendar.WEDNESDAY],data[Calendar.THURSDAY],data[Calendar.FRIDAY],
 				data[Calendar.SATURDAY],data[Calendar.SUNDAY]};
 		data = new DateFormatSymbols().getMonths();
 		MONTHS = new String[]{
 				data[Calendar.JANUARY],data[Calendar.FEBRUARY],data[Calendar.MARCH],
 				data[Calendar.APRIL],data[Calendar.MAY],data[Calendar.JUNE],
 				data[Calendar.JULY],data[Calendar.AUGUST],data[Calendar.SEPTEMBER],
 				data[Calendar.OCTOBER],data[Calendar.NOVEMBER],data[Calendar.DECEMBER]};
 	}
 	
 	private Date selectedDate;
 	private DatePanel datePanel;
 	private DateSpan selectedDateSpan;
 	private MonthCombo monthCombo;
 	private SimpleButton leftYear = null;
 	private SimpleButton rightYear = null;
 	private JPopupMenu popup = null;
 
 	/**
 	 * Constructs the DateSpanSelector.
 	 */
 	public DateSpanSelector()
 	{
 		monthCombo = new MonthCombo();
 
 		datePanel = new DatePanel();
 
 		monthCombo.addItemListener(datePanel);
 
 		setPreferredSize(new Dimension(154, 154));
 		setOpaque(true);
 		setBackground(ColorHelper.getControl());
 		setBorder(CosyUIElements.getPlainBorder(false));
 
 		setLayout(new GridBagLayout());
 
 		JPanel monthPanel = new JPanel(new BorderLayout());
 		
 		SimpleButton leftYear = getLeftYearButton();		
 		SimpleButton rightYear = getRightYearButton();
 		//add(leftYear, new GridBagConstraints(0,0,1,1,0,0,GridBagConstraints.CENTER,GridBagConstraints.NONE, new Insets(0,0,0,0),0,0));
 		//add(rightYear, new GridBagConstraints(2,0,1,1,0,0,GridBagConstraints.CENTER,GridBagConstraints.NONE, new Insets(0,0,0,0),0,0));
 		monthPanel.add(monthCombo,BorderLayout.CENTER);
 		monthPanel.add(leftYear,BorderLayout.WEST);
 		monthPanel.add(rightYear,BorderLayout.EAST);
 		
 		GridBagConstraints constraints = new GridBagConstraints();
 		constraints.fill = GridBagConstraints.BOTH;
 		constraints.gridx = 1;
 		constraints.gridy = 0;
 		constraints.weightx = 1;
 		constraints.weighty = 0;
 		constraints.anchor = GridBagConstraints.CENTER;
 		add(monthPanel, constraints);
 		constraints.gridx = 0;
 		constraints.gridy = 1;
 		constraints.weightx = 1;
 		constraints.weighty = 1;
 		constraints.gridwidth = 3;
 		constraints.anchor = GridBagConstraints.CENTER;
 		add(datePanel, constraints);
 			
 		
 		
 		
 	}
 
 	private SimpleButton getLeftYearButton() {
 		if (leftYear  == null){
 			leftYear = new YearButton(ArrowButton.LEFT);
 			leftYear.addActionListener(new ActionListener() {
 				public void actionPerformed(ActionEvent e){
 					if (monthCombo.getSelectedIndex() > 12) {
 						monthCombo.setSelectedIndex(monthCombo
 					    .getSelectedIndex() - 12);
 					}
 				}
 			});
 	
 			leftYear.setBackground(ColorHelper.getControl());
 			leftYear.setBorder(null);
 			leftYear.setPressedBorder(null);
 		}
 		return leftYear;
 	}
 
 	private SimpleButton getRightYearButton() {
 		if (rightYear == null){
 			rightYear = new YearButton(ArrowButton.RIGHT);
 			rightYear.addActionListener(new ActionListener() {
 				public void actionPerformed(ActionEvent e){
 					if (monthCombo.getSelectedIndex() < (monthCombo
 						    .getItemCount() - 13)) {
 						monthCombo.setSelectedIndex(monthCombo
 							    .getSelectedIndex() + 12);
 						}
 				}
 			});
 			rightYear.setBackground(ColorHelper.getControl());
 			rightYear.setBorder(null);
 			rightYear.setPressedBorder(null);
 		}
 		return rightYear;
 	}
 
 	/**
 	 * Returns true if the two dates are the same for the selector. Dates are the
 	 * same if they have the same year and the same day of year.
 	 *
 	 * @param date1
 	 * @param date2
 	 *
 	 * @return
 	 */
 	public static boolean isSameDate(Date date1, Date date2)
 	{
 		Calendar c1 = new GregorianCalendar();
 		Calendar c2 = new GregorianCalendar();
 		c1.setTime(date1);
 		c2.setTime(date2);
 		
 		return (c1.get(Calendar.YEAR) == c2.get(Calendar.YEAR) 
 			&&  c1.get(Calendar.DAY_OF_YEAR) == c2.get(Calendar.DAY_OF_YEAR));
 //		return date1.getYear() == date2.getYear()
 //		&& date1.getMonth() == date2.getMonth()
 //		&& date1.getDate() == date2.getDate();
 	}
 
 	public void setSelectedDateSpan(DateSpan newSpan) {
 		setSelectedDateSpan(newSpan,false);
 	}
 	
 	/**
 	 * Sets a new date interval to be selected. If null, the selection is
 	 * reset to current date. Also triggers single date selection: if the datespan points to
 	 * the single day, the single selection is synchronized. Otherwise, single
 	 * selection is removed.
 	 *
 	 * @param newSpan
 	 * @param shouldScroll flag indicates whether the calendar should scroll to the 
 	 * 			selected finishing date 
 	 */
 	public void setSelectedDateSpan(DateSpan newSpan, boolean shouldScroll)
 	{
 		DateSpan oldSpan = selectedDateSpan;
 		Date oldDate = selectedDate;
 
 		if (((newSpan != null) && newSpan.equals(oldSpan))
 		    || (newSpan == null && oldSpan == null)) {
 			return;
 		}
 
 		//if (newSpan==null) {
 		//	Date d = GregorianCalendar.getInstance().getTime();	
 		//	newSpan = new DateSpan(d,d);
 		//} 
 
 		selectedDateSpan = newSpan;
 
 		if (newSpan!=null && isSameDate(newSpan.getStartingDate(), newSpan.getFinishingDate())) {
 			selectedDate = newSpan.getFinishingDate();
 		} else {
 			selectedDate = null;
 		}
 
 		if (newSpan==null) {
 			datePanel.clearSelection();
 		} else {
 			datePanel.ensureSelection();
 			datePanel.selectionStartDate.setTime(newSpan.getStartingDate());
 			normalizeToMiddleOfDay(datePanel.selectionStartDate);
 			datePanel.selectionFinishDate.setTime(newSpan.getFinishingDate());
 			normalizeToMiddleOfDay(datePanel.selectionFinishDate);
 		}
 
 		if (shouldScroll) {
 			Calendar finish = GregorianCalendar.getInstance();
 			if (newSpan != null) {
 				finish.setTime(newSpan.getFinishingDate());
 			}
 			datePanel.displayMonthDate.set(Calendar.YEAR, finish.get(Calendar.YEAR));
 			datePanel.displayMonthDate.set(Calendar.MONTH, finish.get(Calendar.MONTH));
 			Calendar date = createCopy(datePanel.displayMonthDate);
 			date.set(Calendar.DAY_OF_MONTH, 1);
 			normalizeToBeginningOfDay(date);
 			monthCombo.setSelectedItem(date);
 			monthCombo.repaint();
 		}
 		
 		datePanel.populateDateList();
 		
 		firePropertyChange("selectedDateSpan", oldSpan, selectedDateSpan);
 		firePropertyChange("selectedDate", oldDate, selectedDate);
 	}
 
 	/**
 	 * Returns the selected date interval.
 	 *
 	 * @return DateSpan
 	 */
 	public DateSpan getSelectedDateSpan()
 	{
 		return selectedDateSpan;
 	}
 
 	/**
 	 * Copies date from te source to the destination.
 	 *
 	 * @param source source calendar
 	 * @param destination destination calendar
 	 */
 	public static void copyDate(Calendar source, Calendar destination)
 	{
 		destination.set(source.get(Calendar.YEAR), source.get(Calendar.MONTH),
 		    source.get(Calendar.DAY_OF_MONTH),
 		    source.get(Calendar.HOUR_OF_DAY), source.get(Calendar.MINUTE),
 		    source.get(Calendar.SECOND));
 	}
 
 	/**
 	 * Creates a copy of the calendar.
 	 *
 	 * @param source calendar to be copies
 	 *
 	 * @return a copy of the given calendar
 	 */
 	public static Calendar createCopy(Calendar source)
 	{
 		Calendar retVal = Calendar.getInstance();
 		copyDate(source, retVal);
 
 		return retVal;
 	}
 
 	/**
 	 * Normalizes date to the beginning of the day. Needed for
 	 * comparison of Calendars, when only  DAY, MONTH and YEAR values are
 	 * relevant.
 	 *
 	 * @param date Calendar
 	 */
 	public static void normalizeToBeginningOfDay(Calendar date)
 	{
 		date.set(Calendar.HOUR_OF_DAY, 0);
 		date.set(Calendar.MINUTE, 0);
 		date.set(Calendar.SECOND, 0);
 		date.set(Calendar.MILLISECOND, 0);
 	}
 
 	/**
 	 * Normalizes date to the last milisecond of the day. Needed for
 	 * comparison of Calendars, when only  DAY, MONTH and YEAR values are
 	 * relevant.
 	 *
 	 * @param date Calendar
 	 */
 	public static void normalizeToEndOfDay(Calendar date)
 	{
 		date.set(Calendar.HOUR_OF_DAY, 23);
 		date.set(Calendar.MINUTE, 59);
 		date.set(Calendar.SECOND, 59);
 		date.set(Calendar.MILLISECOND, 999);
 	}
 
 	/**
 	 * Normalizes date to the middle of the day. Needed for comparison
 	 * of Calendars, when only  DAY, MONTH and YEAR values are relevant.
 	 *
 	 * @param date Calendar
 	 */
 	public static void normalizeToMiddleOfDay(Calendar date)
 	{
 		date.set(Calendar.HOUR_OF_DAY, 12);
 		date.set(Calendar.MINUTE, 0);
 		date.set(Calendar.SECOND, 0);
 		date.set(Calendar.MILLISECOND, 0);
 	}
 
 	/**
 	 * Sets the single selected date. If null is set, the current selection is
 	 * reset to current date. Also triggers dateSpan selection to reflect the date
 	 * selection.
 	 *
 	 * @param date
 	 */
 	public void setSelectedDate(Date date)
 	{
 		Date oldDate = selectedDate;
 
 		if (((date != null) && date.equals(oldDate)
 		    || date == null && selectedDate == null)) {
 			return;
 		}
 
 		if (date == null) {
 			setSelectedDateSpan(null);
 		} else {
 			setSelectedDateSpan(new DateSpan(date, date));
 		}
 	}
 
 	/**
 	 * Returns the selected date if single date is selected otherwise null.
 	 *
 	 * @return single date selection
 	 */
 	public Date getSelectedDate()
 	{
 		return selectedDate;
 	}
 
 	/**
 	 * Returns whether a single date is selected.
 	 *
 	 * @return true if a single date is selected, false otherwise.
 	 */
 	public boolean isSingleDateSelected()
 	{
 		return (selectedDate != null);
 	}
 	
 	/*
 	 * (non-Javadoc)
 	 * @see javax.swing.JComponent#setEnabled(boolean)
 	 */
 	@Override
 	public void setEnabled(boolean enabled) {
 		super.setEnabled(enabled);
 		monthCombo.setEnabled(enabled);
 		datePanel.setEnabled(enabled);
 		getLeftYearButton().setEnabled(enabled);
 		getRightYearButton().setEnabled(enabled);
 	}
 
 	private JPopupMenu getPopup() {
 		if (popup == null){
 			// create popup
 			popup = new JPopupMenu("");
 			
 			JMenuItem todayItem = new JMenuItem("Go to today");
 			todayItem.addActionListener(new ActionListener(){
 				public void actionPerformed(ActionEvent e) {
 					//setSelectedDateSpan(new DateSpan(new Date(), new Date()), true);
 					if (getSelectedDateSpan() == null) return;
 					Calendar start = GregorianCalendar.getInstance();
 					datePanel.displayMonthDate.set(Calendar.YEAR, start.get(Calendar.YEAR));
 					datePanel.displayMonthDate.set(Calendar.MONTH, start.get(Calendar.MONTH));
 					Calendar date = createCopy(datePanel.displayMonthDate);
 					date.set(Calendar.DAY_OF_MONTH, 1);
 					normalizeToBeginningOfDay(date);
 					monthCombo.setSelectedItem(date);
 					monthCombo.repaint();
 					datePanel.populateDateList();
 				}			
 			});
 			popup.add(todayItem);
 			
 			JMenuItem selStartItem = new JMenuItem("Go to selection start");
 			selStartItem.addActionListener(new ActionListener(){
 				public void actionPerformed(ActionEvent e) {
 					if (getSelectedDateSpan() == null) return;
 					Calendar start = GregorianCalendar.getInstance();
 					start.setTime(getSelectedDateSpan().getStartingDate());
 					datePanel.displayMonthDate.set(Calendar.YEAR, start.get(Calendar.YEAR));
 					datePanel.displayMonthDate.set(Calendar.MONTH, start.get(Calendar.MONTH));
 					Calendar date = createCopy(datePanel.displayMonthDate);
 					date.set(Calendar.DAY_OF_MONTH, 1);
 					normalizeToBeginningOfDay(date);
 					monthCombo.setSelectedItem(date);
 					monthCombo.repaint();
 					datePanel.populateDateList();						
 				}			
 			});
 			popup.add(selStartItem);
 			
 			JMenuItem selEndItem = new JMenuItem("Go to selection end");
 			selEndItem.addActionListener(new ActionListener(){
 				public void actionPerformed(ActionEvent e) {
 					if (getSelectedDateSpan() == null) return;
 					Calendar end = GregorianCalendar.getInstance();
 					end.setTime(getSelectedDateSpan().getFinishingDate());
 					datePanel.displayMonthDate.set(Calendar.YEAR, end.get(Calendar.YEAR));
 					datePanel.displayMonthDate.set(Calendar.MONTH, end.get(Calendar.MONTH));
 					Calendar date = createCopy(datePanel.displayMonthDate);
 					date.set(Calendar.DAY_OF_MONTH, 1);
 					normalizeToBeginningOfDay(date);
 					monthCombo.setSelectedItem(date);
 					monthCombo.repaint();
 					datePanel.populateDateList();
 				}			
 			});
 			popup.add(selEndItem);
 			
 		}
 		return popup;
 	}
 	
 	/**
 	 * For testing and demonstration purposes only.
 	 *
 	 * @param args String[]
 	 */
 	public static void main(String[] args)
 	{
 		JPanel pan = new JPanel();
 		pan.setLayout(new CardLayout(10, 10));
 		DateSpanSelector selector = new DateSpanSelector();
 		//DateSpan span = new DateSpan(new Date(System.currentTimeMillis() + 86400000L*60), 1000000000L);
 		//DateSpan span = new DateSpan(new Date(System.currentTimeMillis()), 500000000L);
 		//selector.setSelectedDateSpan(span, true);
 		pan.add(selector, "Date");
 		selector.addPropertyChangeListener("selectedDateSpan", new PropertyChangeListener(){
 			public void propertyChange(PropertyChangeEvent evt) {
 				System.out.println(evt.getNewValue());
 			}
 		});
 		JFrame frame = new JFrame("CalendarSelector Testing Applet");
 		frame.getContentPane().add(pan);
 		frame.setSize(300, 300);
 		frame.addWindowListener(new WindowAdapter() {
 				public void windowClosing(WindowEvent e)
 				{
 					System.exit(0);
 				}
 			});
 		frame.setVisible(true);
 		
 		try {
 //			Thread.sleep(2000);
 //			selector.setEnabled(false);
 //			Thread.sleep(2000);
 //			selector.setEnabled(true);
 //			Thread.sleep(2000);
 //			selector.setEnabled(false);
 			Thread.sleep(2000);
 			selector.setEnabled(true);
 			
 		} catch (InterruptedException e1) {
 			// TODO Auto-generated catch block
 			e1.printStackTrace();
 		}
 		
 		
 	}
 }
 
 /* __oOo__ */