/**
* @file  cusdr_oglDistancePanel.cpp
* @brief distance panel class for cuSDR
* @author Hermann von Hasseln, DL3HVH
* @version 0.1
* @date 2012-02-14
*/

/*
 *   Copyright 2012 Hermann von Hasseln, DL3HVH
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License version 2 as
 *   published by the Free Software Foundation
 *
 *   This program 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 Library General Public
 *   License along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#define LOG_GRAPHICS

#include "cusdr_oglDistancePanel.h"

//#include <QtGui>
//#include <QDebug>
////#include <QFileInfo>
//#include <QTimer>
//#include <QImage>
//#include <QString>
//#include <QGLFramebufferObject>


#ifndef GL_MULTISAMPLE
#define GL_MULTISAMPLE  0x809D
#endif

QGLDistancePanel::QGLDistancePanel(QWidget *parent)
	: QGLWidget(QGLFormat(QGL::SampleBuffers|QGL::AlphaChannel), parent)

	, set(Settings::instance())
	, m_serverMode(set->getCurrentServerMode())
	, m_hwInterface(set->getHWInterface())
	, m_dataEngineState(QSDR::DataEngineDown)
	, m_panMode(set->getPanadapterMode(0))
	, m_mousePos(QPoint(-1, -1))
	, m_mouseDownPos(QPoint(-1, -1))
	, m_specAveragingCnt(set->getSpectrumAveragingCnt(0))
	, m_freqRulerDisplayWidth(0)
	, m_panSpectrumMinimumHeight(70)
	, m_spectrumUpdate(false)
	, m_showZerodBmLine(false)
	, m_spectrumVertexColorUpdate(false)
	, m_spectrumColorsChanged(true)
	, m_showChirpFFT(false)
	, m_spectrumAveraging(set->getSpectrumAveraging(0))
	, m_spectrumAveragingOld(m_spectrumAveraging)
	, m_crossHairCursor(false)
	, m_panGrid(set->getPanGridStatus(0))
	, m_freqRulerPosition(0.5)
	, m_distRulerDisplayDelta(0.0)
	, m_distRulerDisplayDeltaStep(500.0)
	, m_distRulerMaxDist(150000.0)
	, m_freqScaleZoomFactor(1.0f)
	, m_distScaleZoomFactor(1.0) // 0.2 .. 1.0
	, m_scaleMult(1.0f)
	, m_filterLowerFrequency(-3050.0)
	, m_filterUpperFrequency(-150.0)
	, m_snapMouse(3)
	, m_sampleRate(set->getSampleRate())
	, m_downRate(set->getChirpDownSampleRate())
	, m_chirpBufferLength(set->getChirpBufferLength())
{
//	QGL::setPreferredPaintEngine(QPaintEngine::OpenGL);

	setAutoBufferSwap(true);
	setAutoFillBackground(false);
	
	setMouseTracking(true);
	setFocusPolicy(Qt::StrongFocus);

	setupDisplayRegions(size());
	m_oldWidth = size().width();
	
	m_rxDataList = set->getReceiverDataList();
	//m_frequency = m_rxDataList.at(0).frequency;
	m_frequency = m_rxDataList.at(0).vfoFrequency;

	m_dBmScalePanadapterRenew = true;
	m_dBmScalePanadapterUpdate = true;
	m_freqScalePanadapterRenew = true;
	m_freqScalePanadapterUpdate = true;
	m_panGridRenew = true;
	m_panGridUpdate = true;

	HamBand band = m_rxDataList.at(0).hamBand;

	m_dBmPanMin = m_rxDataList.at(0).dBmPanScaleMinList.at(band);
	m_dBmPanMax = m_rxDataList.at(0).dBmPanScaleMaxList.at(band);

	m_filterLowerFrequency = m_rxDataList.at(0).filterLo;
	m_filterUpperFrequency = m_rxDataList.at(0).filterHi;

	fonts = new CFonts(this);
	m_fonts = fonts->getFonts();

	m_oglTextTiny = new OGLText(m_fonts.tinyFont);
	m_oglTextSmall = new OGLText(m_fonts.smallFont);
	m_oglTextNormal = new OGLText(m_fonts.normalFont);

	timer = 0;

	setupConnections();

	m_displayTime.start();
	m_resizeTime.start();
	//freqChangeTimer.start();
	
	memset(m_spectrumBuffer, -10000, 4 * BUFFER_SIZE * sizeof(float));
	memset(m_distanceSpectrumBuffer, -10000, 16 * BUFFER_SIZE * sizeof(float));

	m_kilometersPerGate = 0.5f * 3E5 / (m_sampleRate/m_downRate);

	m_dBmPanLogGain = 69; // allow user to calibrate this value

	m_dBmDistMin = set->getdBmDistScaleMin();
	m_dBmDistMax = set->getdBmDistScaleMax();
	m_dBmDistScaleMin = m_dBmDistMin;
	m_dBmDistScaleMax = m_dBmDistMax;

	m_panSpectrumBinsLength = 0;	
	
	/*m_bkgRed   = (GLfloat)(set->getPanadapterColors().panBackgroundColor.red() / 256.0);
	m_bkgGreen = (GLfloat)(set->getPanadapterColors().panBackgroundColor.green() / 256.0);
	m_bkgBlue  = (GLfloat)(set->getPanadapterColors().panBackgroundColor.blue() / 256.0);*/

	m_red	= (GLfloat)(set->getPanadapterColors().panLineColor.red() / 256.0);
	m_green = (GLfloat)(set->getPanadapterColors().panLineColor.green() / 256.0);
	m_blue	= (GLfloat)(set->getPanadapterColors().panLineColor.blue() / 256.0);

	m_redF	 = (GLfloat)(set->getPanadapterColors().panLineFilledColor.red() / 256.0);
	m_greenF = (GLfloat)(set->getPanadapterColors().panLineFilledColor.green() / 256.0);
	m_blueF  = (GLfloat)(set->getPanadapterColors().panLineFilledColor.blue() / 256.0);

	m_redST	  = (GLfloat)(set->getPanadapterColors().panSolidTopColor.red() / 256.0);
	m_greenST = (GLfloat)(set->getPanadapterColors().panSolidTopColor.green() / 256.0);
	m_blueST  = (GLfloat)(set->getPanadapterColors().panSolidTopColor.blue() / 256.0);

	m_redSB   = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.red() / 256.0);
	m_greenSB = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.green() / 256.0);
	m_blueSB  = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.blue() / 256.0);

	m_frequencyScaleFBO = 0;
	m_dBmScaleFBO = 0;
	m_panadapterGridFBO = 0;
	m_textureFBO = 0;
	
	if (m_specAveragingCnt > 0)
		m_scale = 1.0f / m_specAveragingCnt;
	else
		m_scale = 1.0f;

	memset(m_tmpBuf, 0, SAMPLE_BUFFER_SIZE * sizeof(float));

	updateGL();
}

QGLDistancePanel::~QGLDistancePanel() {

	disconnect(set, 0, this, 0);
	
	makeCurrent();
	glFinish();

	if (m_frequencyScaleFBO) {

		delete m_frequencyScaleFBO;
		m_frequencyScaleFBO = 0;
	}

	if (m_textureFBO) {

		delete m_textureFBO;
		m_textureFBO = 0;
	}

	if (m_dBmScaleFBO) {

		delete m_dBmScaleFBO;
		m_dBmScaleFBO = 0;
	}

	if (m_panadapterGridFBO) {

		delete m_panadapterGridFBO;
		m_panadapterGridFBO = 0;
	}

	while (!specAv_queue.isEmpty())
		specAv_queue.dequeue();
}

//QSize QGLDistancePanel::minimumSizeHint() const {
//	
//	//return QSize(1000, 1024);
//	return QSize(width(), height());
//}

QSize QGLDistancePanel::sizeHint() const {
	
	return QSize(width(), height());
}

void QGLDistancePanel::setupConnections() {

	CHECKED_CONNECT(
		set,
		SIGNAL(systemStateChanged(
					QObject *,
					QSDR::_Error,
					QSDR::_HWInterfaceMode,
					QSDR::_ServerMode,
					QSDR::_DataEngineState)),
		this,
		SLOT(systemStateChanged(
					QObject *,
					QSDR::_Error,
					QSDR::_HWInterfaceMode,
					QSDR::_ServerMode,
					QSDR::_DataEngineState)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(graphicModeChanged(
					QObject *,
					int,
					PanGraphicsMode,
					WaterfallColorMode)),
		this, 
		SLOT(graphicModeChanged(
					QObject *,
					int,
					PanGraphicsMode,
					WaterfallColorMode)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(freqRulerPositionChanged(float, int)), 
		this, 
		SLOT(freqRulerPositionChanged(float, int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(sampleRateChanged(QObject *, int)), 
		this, 
		SLOT(sampleRateChanged(QObject *, int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(filterFrequenciesChanged(QObject *, int, qreal, qreal)), 
		this, 
		SLOT(setFilterFrequencies(QObject *, int, qreal, qreal)));

	CHECKED_CONNECT_OPT(
		set, 
		SIGNAL(chirpSpectrumBufferChanged(int, qint64, const float *)),
		this,
		SLOT(distanceSpectrumBufferChanged(int, qint64, const float *)),
		Qt::DirectConnection);

	CHECKED_CONNECT(
		set, 
		SIGNAL(chirpFFTShowChanged(bool)),
		this,
		SLOT(setChirpFFTShow(bool)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(waterfallTimeChanged(int, int)),
		this,
		SLOT(setWaterfallTime(int, int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(waterfallOffesetLoChanged(int, int)),
		this,
		SLOT(setWaterfallOffesetLo(int, int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(waterfallOffesetHiChanged(int, int)),
		this,
		SLOT(setWaterfallOffesetHi(int, int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(spectrumAveragingChanged(bool)), 
		this, 
		SLOT(setSpectrumAveraging(bool)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(spectrumAveragingCntChanged(int)), 
		this, 
		SLOT(setSpectrumAveragingCnt(int)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(panGridStatusChanged(bool)),
		this,
		SLOT(setPanGridStatus(bool)));

	CHECKED_CONNECT(
		set, 
		SIGNAL(panadapterColorChanged()),
		this,
		SLOT(setPanadapterColors()));
}

void QGLDistancePanel::initializeGL() {

	if (!isValid()) return;
	
	/*QOpenGLInfo glInfo;
	glInfo.getInfo();
	glInfo.printSelf();*/

	//*****************************************************************
	// default initialization

	//glShadeModel(GL_FLAT);
	glShadeModel(GL_SMOOTH);
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment
	//glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    //glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);

	glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
	glDisable(GL_CULL_FACE);
    
	m_cnt = 0;

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}

void QGLDistancePanel::paintGL() {

	switch (m_serverMode) {

		case QSDR::SDRMode:

			drawGLRect(QRect(0, 0, width(), height()), QColor(0, 0, 0));
			break;

		case QSDR::ChirpWSPR:
		case QSDR::ChirpWSPRFile:

			//if (freqChangeTimer.elapsed() > 50)  m_spectrumAveraging = m_spectrumAveragingOld;

			if (m_resizeTime.elapsed() > 100 || m_dataEngineState == QSDR::DataEngineDown) {

				paintReceiverDisplay();
				paintChirpWSPRDisplay();
			}
			
			break;

		default:
			break;
	}
}
 
//****************************************************
// painting modes
void QGLDistancePanel::paintReceiverDisplay() {
 
	QRect mouse_rect(0, 0, 100, 100);
	mouse_rect.moveCenter(m_mousePos);

	drawPanadapter();
	drawPanHorizontalScale();
	drawPanVerticalScale();

	if (m_panGrid)
		drawPanadapterGrid();

	drawPanFilter();
	
	if (m_mouseRegion == panadapterRegion && m_crossHairCursor)
		drawCrossHair();

	m_oldFreq = m_frequency;
 }

void QGLDistancePanel::paintChirpWSPRDisplay() {

	//drawGLBackground(m_distanceSpectrumRect);

	distanceSpectrumBufferMutex.lock();
	drawDistanceSpectrum();
	distanceSpectrumBufferMutex.unlock();

	drawDistHorizontalScale();
	drawDistVerticalScale();
	
	//// chirp distance spectrum
	//m_distancePanadapter->drawGLDistanceRuler(
	//				m_freqScaleDistancePanRect,
	//				m_freqScalePanadapterRect,
	//				m_mouseRegion,
	//				m_distRulerZoomFactor,
	//				m_distRulerDisplayDelta,
	//				m_kilometersPerGate,
	//				m_showChirpFFT,
	//				m_chirpBufferLength);

	//m_distancePanadapter->drawGLdBmScale(
	//				m_dBmScaleDistancePanRect,
	//				m_distanceSpectrumRect,
	//				m_mouseRegion,
	//				m_dBmDistScaleMin,
	//				m_dBmDistScaleMax,
	//				m_showZerodBmLine);

	//m_distancePanadapter->drawGLGrid(m_distanceSpectrumRect, m_dBmScaleDistancePanRect);
}

void QGLDistancePanel::drawPanadapter() {

	GLint vertexArrayLength = (GLint)m_panadapterBins.size();

	GLint height = m_panRect.height();
	GLint x1 = m_panRect.left();
	GLint y1 = m_panRect.top();
	GLint x2 = x1 + m_panRect.width();
	GLint y2 = y1 + m_panRect.height();

	// y scale
	float yScale;
	float yScaleColor;
	float yTop;
	
	qreal dBmRange = qAbs(m_dBmPanMax - m_dBmPanMin);

	yScale = m_panRect.height() / dBmRange;
	//yScaleColor = 4.0f / dBmRange;
	yScaleColor = 10.0f / dBmRange;
	yTop = (float) y2;
	
	if (m_dataEngineState == QSDR::DataEngineUp)
		glClear(GL_DEPTH_BUFFER_BIT);
	else
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glEnable(GL_MULTISAMPLE);
	glEnable(GL_LINE_SMOOTH);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	glLineWidth(1);

	// draw background
	if (m_dataEngineState == QSDR::DataEngineUp) {

		if (m_panGrid) {

			glBegin(GL_TRIANGLE_STRIP);
				glColor3f(0.15f, 0.15f, 0.3f);	glVertex3f(x1, y1, -3.0); // top left corner
				glColor3f(0.15f, 0.15f, 0.3f);	glVertex3f(x2, y1, -3.0); // top right corner
				glColor3f(0.15f, 0.15f, 0.51f);	glVertex3f(x1, y2, -3.0); // bottom left corner
				glColor3f(0.15f, 0.15f, 0.61f);	glVertex3f(x2, y2, -3.0); // bottom right corner
			glEnd();
		}
		else {

			glBegin(GL_TRIANGLE_STRIP);
				glColor3f(0.05f, 0.05f, 0.2f);	glVertex3f(x1, y1, -3.0); // top left corner
				glColor3f(0.05f, 0.05f, 0.2f);	glVertex3f(x2, y1, -3.0); // top right corner
				glColor3f(0.05f, 0.05f, 0.31f);	glVertex3f(x1, y2, -3.0); // bottom left corner
				glColor3f(0.05f, 0.05f, 0.41f);	glVertex3f(x2, y2, -3.0); // bottom right corner
			glEnd();
		}
	}
	else {

		drawGLRect(m_panRect, QColor(30, 30, 50, 155), -3.0f);
	}

	//glBegin(GL_TRIANGLE_STRIP);
	//glColor3f(m_bkgRed,       m_bkgGreen,       m_bkgBlue);			glVertex3f(x1, y1, -3.0); // top left corner
	//glColor3f(m_bkgRed,       m_bkgGreen,       m_bkgBlue);			glVertex3f(x2, y1, -3.0); // top right corner
	//glColor3f(m_bkgRed * 1.2, m_bkgGreen * 1.2, m_bkgBlue * 1.2);	glVertex3f(x1, y2, -3.0); // bottom left corner
	//glColor3f(m_bkgRed * 1.6, m_bkgGreen * 1.6, m_bkgBlue * 1.6);	glVertex3f(x2, y2, -3.0); // bottom right corner
	//glEnd();

	// set a scissor box
	glScissor(x1, size().height() - y2, x2, height);
	glEnable(GL_SCISSOR_TEST);

	TGL3float *vertexArray = new TGL3float[vertexArrayLength];
	TGL3float *vertexColorArray = new TGL3float[vertexArrayLength];

	TGL3float *vertexArrayBg = new TGL3float[2*vertexArrayLength];
	TGL3float *vertexColorArrayBg = new TGL3float[2*vertexArrayLength];
	
	switch (m_panMode) {

		case (PanGraphicsMode) FilledLine:

			for (int i = 0; i < vertexArrayLength; i++) {
			
				mutex.lock();
				vertexColorArrayBg[2*i].x = m_redF;
				vertexColorArrayBg[2*i].y = m_greenF;
				vertexColorArrayBg[2*i].z = m_blueF;
								
				vertexColorArrayBg[2*i+1].x = 0.3 * m_redF;
				vertexColorArrayBg[2*i+1].y = 0.3 * m_greenF;
				vertexColorArrayBg[2*i+1].z = 0.3 * m_blueF;
				
				vertexColorArray[i].x = m_red   * (yScaleColor * m_panadapterBins.at(i));
				vertexColorArray[i].y = m_green * (yScaleColor * m_panadapterBins.at(i));
				vertexColorArray[i].z = m_blue  * (yScaleColor * m_panadapterBins.at(i));
				mutex.unlock();

				vertexArrayBg[2*i].x = (GLfloat)(i/m_scaleMult);
				vertexArrayBg[2*i].y = (GLfloat)(yTop - yScale * m_panadapterBins.at(i));
				vertexArrayBg[2*i].z = -2.5;

				vertexArrayBg[2*i+1].x = (GLfloat)(i/m_scaleMult);
				vertexArrayBg[2*i+1].y = (GLfloat)yTop;
				vertexArrayBg[2*i+1].z = -2.5;
	
				vertexArray[i].x = (GLfloat)(i/m_scaleMult);
				vertexArray[i].y = (GLfloat)(yTop - yScale * m_panadapterBins.at(i));
				vertexArray[i].z = -1.0;
			}
			
			glEnableClientState(GL_VERTEX_ARRAY);
			glEnableClientState(GL_COLOR_ARRAY);
				
			glVertexPointer(3, GL_FLOAT, 0, vertexArrayBg);
			glColorPointer(3, GL_FLOAT, 0, vertexColorArrayBg);
			glDrawArrays(GL_QUAD_STRIP, 0, 2*vertexArrayLength);

			glVertexPointer(3, GL_FLOAT, 0, vertexArray);
			glColorPointer(3, GL_FLOAT, 0, vertexColorArray);
			glDrawArrays(GL_LINE_STRIP, 0, vertexArrayLength);

			glDisableClientState(GL_VERTEX_ARRAY);
			glDisableClientState(GL_COLOR_ARRAY); 

			delete[] vertexArray;
			delete[] vertexColorArray;
			delete[] vertexArrayBg;
			delete[] vertexColorArrayBg;

			break;

		case (PanGraphicsMode) Line:

			for (int i = 0; i < vertexArrayLength; i++) {
	
				mutex.lock();
				vertexColorArray[i].x = m_red	* (yScaleColor * m_panadapterBins.at(i));
				vertexColorArray[i].y = m_green * (yScaleColor * m_panadapterBins.at(i));
				vertexColorArray[i].z = m_blue  * (yScaleColor * m_panadapterBins.at(i));
				mutex.unlock();
				
				vertexArray[i].x = (GLfloat)(i/m_scaleMult);
				vertexArray[i].y = (GLfloat)(yTop - yScale * m_panadapterBins.at(i));
				vertexArray[i].z = -1.0;
			}
		
			glEnableClientState(GL_VERTEX_ARRAY);
			glEnableClientState(GL_COLOR_ARRAY);
				
			glVertexPointer(3, GL_FLOAT, 0, vertexArray);
			glColorPointer(3, GL_FLOAT, 0, vertexColorArray);
			glDrawArrays(GL_LINE_STRIP, 0, vertexArrayLength);
			
			glDisableClientState(GL_VERTEX_ARRAY);
			glDisableClientState(GL_COLOR_ARRAY);

			delete[] vertexArray;
			delete[] vertexColorArray;
			delete[] vertexArrayBg;
			delete[] vertexColorArrayBg;
			
			break;

		case (PanGraphicsMode) Solid:

			glDisable(GL_MULTISAMPLE);
			glDisable(GL_LINE_SMOOTH);

			for (int i = 0; i < vertexArrayLength; i++) {
			
				mutex.lock();
				vertexColorArrayBg[2*i].x = m_redST;
				vertexColorArrayBg[2*i].y = m_greenST;
				vertexColorArrayBg[2*i].z = m_blueST;
								
				vertexColorArrayBg[2*i+1].x = m_redSB;
				vertexColorArrayBg[2*i+1].y = m_greenSB;
				vertexColorArrayBg[2*i+1].z = m_blueSB;
				mutex.unlock();

				vertexArrayBg[2*i].x = (GLfloat)(i/m_scaleMult);
				vertexArrayBg[2*i].y = (GLfloat)(yTop - yScale * m_panadapterBins.at(i));
				vertexArrayBg[2*i].z = -2.0f;

				vertexArrayBg[2*i+1].x = (GLfloat)(i/m_scaleMult);
				vertexArrayBg[2*i+1].y = (GLfloat)yTop;
				vertexArrayBg[2*i+1].z = -2.0f;
			}
			
			glEnableClientState(GL_VERTEX_ARRAY);
			glEnableClientState(GL_COLOR_ARRAY);
				
			glVertexPointer(3, GL_FLOAT, 0, vertexArrayBg);
			glColorPointer(3, GL_FLOAT, 0, vertexColorArrayBg);
			//glDrawArrays(GL_QUAD_STRIP, 0, 2*vertexArrayLength);
			glDrawArrays(GL_LINES, 0, 2*vertexArrayLength);

			glDisableClientState(GL_VERTEX_ARRAY);
			glDisableClientState(GL_COLOR_ARRAY);

			//glEnable(GL_MULTISAMPLE);
			//glEnable(GL_LINE_SMOOTH);

			delete[] vertexArray;
			delete[] vertexColorArray;
			delete[] vertexArrayBg;
			delete[] vertexColorArrayBg;

			break;
	}

	glDisable(GL_MULTISAMPLE);
	glDisable(GL_LINE_SMOOTH);

	// disable scissor box
	glDisable(GL_SCISSOR_TEST);
} 

void QGLDistancePanel::drawPanVerticalScale() {

	if (!m_dBmScalePanRect.isValid()) return;

	int width = m_dBmScalePanRect.width();
	int height = m_dBmScalePanRect.height();

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glColor3f(0.65f, 0.76f, 0.81f);
	
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	
	if (!m_dBmScaleFBO || m_dBmScalePanadapterUpdate || m_dBmScalePanadapterRenew)	{

		if (!m_dBmScaleFBO || m_dBmScalePanadapterRenew) {

			if (m_dBmScaleFBO) {
			
				delete m_dBmScaleFBO;
				m_dBmScaleFBO = 0;
			}
			m_dBmScaleFBO = new QGLFramebufferObject(width, height);
		}

		m_dBmScaleFBO->bind();
			renderPanVerticalScale();
		m_dBmScaleFBO->release();
		
		m_dBmScalePanadapterUpdate = false;
		m_dBmScalePanadapterRenew = false;
	}
		
	renderTexture(m_dBmScalePanRect, m_dBmScaleFBO->texture(), 0.0f);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glColor3f(0.65f, 0.76f, 0.81f);
}

void QGLDistancePanel::drawPanHorizontalScale() {

	if (!m_freqScalePanRect.isValid()) return;

	int width = m_freqScalePanRect.width();
	int height = m_freqScalePanRect.height();

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glColor3f(0.65f, 0.76f, 0.81f);
	
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);

	if (!m_frequencyScaleFBO || m_freqScalePanadapterUpdate || m_freqScalePanadapterRenew) {

		if (!m_frequencyScaleFBO || m_freqScalePanadapterRenew) {

			if (m_frequencyScaleFBO) {
			
				delete m_frequencyScaleFBO;
				m_frequencyScaleFBO = 0;
			}

			m_frequencyScaleFBO = new QGLFramebufferObject(width, height);
		}

		glPushAttrib(GL_VIEWPORT_BIT);
		glViewport(0, 0, width, height);
		setProjectionOrthographic(width, height);
		
		m_frequencyScaleFBO->bind();
			renderPanHorizontalScale();
		m_frequencyScaleFBO->release();

		glPopAttrib();
		glViewport(0, 0, size().width(), size().height());
		setProjectionOrthographic(size().width(), size().height());
		
		m_freqScalePanadapterUpdate = false;
		m_freqScalePanadapterRenew = false;
	}

	renderTexture(m_freqScalePanRect, m_frequencyScaleFBO->texture(), 0.0f);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glColor3f(0.65f, 0.76f, 0.81f);
}

void QGLDistancePanel::drawPanadapterGrid() {

	if (!m_panRect.isValid()) return;

	int width = m_panRect.width();
	int height = m_panRect.height();

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	//glColor4f(0.35, 0.46, 0.51, 0.7);
	//glColor4f(0.45, 0.56, 0.61, 1.0);
	glColor4f(0.45f, 0.56f, 0.61f, 0.8f);
	
	glDisable(GL_MULTISAMPLE);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	
	if (!m_panadapterGridFBO || m_panGridUpdate || m_panGridRenew)	{

		if (!m_panadapterGridFBO || m_panGridRenew) {

			if (m_panadapterGridFBO) {
			
				delete m_panadapterGridFBO;
				m_panadapterGridFBO = 0;
			}

			m_panadapterGridFBO = new QGLFramebufferObject(width, height);
		}

		glPushAttrib(GL_VIEWPORT_BIT);
		glViewport(0, 0, width, height);
		setProjectionOrthographic(width, height);
		
		m_panadapterGridFBO->bind();
			renderPanadapterGrid();
		m_panadapterGridFBO->release();

		glPopAttrib();
		glViewport(0, 0, size().width(), size().height());
		setProjectionOrthographic(size().width(), size().height());
		
		m_panGridUpdate = false;
		m_panGridRenew = false;
	}

	//renderTexture(m_panRect, m_panadapterGridFBO->texture(), -2.0f);
	//renderTexture(m_panRect, m_panadapterGridFBO->texture(), -1.5f);
	renderTexture(m_panRect, m_panadapterGridFBO->texture(), -2.0f);
	
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glColor3f(0.65f, 0.76f, 0.81f);
	glEnable(GL_MULTISAMPLE);
}

void QGLDistancePanel::drawPanFilter() {

	qreal freqLo = m_filterLowerFrequency / m_sampleRate;
	qreal freqHi = m_filterUpperFrequency / m_sampleRate;

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_BLEND);
	//glColor4f(0.65, 0.65, 0.65, 0.25);
	QColor color = QColor(150, 150, 150, 100);

	GLint x1 = m_panRect.left() + qRound((qreal)(m_panRect.width()/2.0f) + freqLo * m_panRect.width() / m_freqScaleZoomFactor);
	GLint x2 = m_panRect.left() + qRound((qreal)(m_panRect.width()/2.0f) + freqHi * m_panRect.width() / m_freqScaleZoomFactor);
	GLint y1 = m_panRect.top() + 1;
	GLint y2 = m_panRect.top() + m_panRect.height() - 1;

	QRect filterRect = QRect(x1, y1, x2 - x1, y2 - y1);

	if ((x1 >= m_panRect.left() && x1 <= m_panRect.right()) ||
		(x2 >= m_panRect.left() && x2 <= m_panRect.right()) ||
		(x1 < m_panRect.left() && x2 > m_panRect.right()))
	{
		if (filterRect.height() > 5) 
			drawGLRect(filterRect, color, 3.0);
	}

	// draw a line for the display center
	y1 = m_panRect.top() + 3;
	y2 = m_panRect.top() + (m_panRect.height() - 3);

	if (y2 > y1 + 3) {

		GLint x = m_panRect.width()/2;
			
		color = set->getPanadapterColors().panCenterLineColor;

		//glDisable(GL_LINE_SMOOTH);
		glDisable(GL_MULTISAMPLE);
		glLineWidth(1);
		glColor4ub(color.red(), color.green(), color.blue(), color.alpha());
		glBegin(GL_LINES);
			/*glVertex2i(x, y1);
			glVertex2i(x, y2);*/
			glVertex3f(x, y1, 4.0f);
			glVertex3f(x, y2, 4.0f);
		glEnd();
		glEnable(GL_MULTISAMPLE);
	}
}

void QGLDistancePanel::drawCrossHair() {

	QRect rect(0, m_panRect.top(), width(), height() - m_panRect.top());

	int x = m_mousePos.x();
	int y = m_mousePos.y();

	glDisable(GL_MULTISAMPLE);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glDisable(GL_LINE_SMOOTH);
	glLineWidth(1.0f);

	qglColor(QColor(255, 255, 255, 80));

	// set a scissor box
	glScissor(rect.left(), rect.top(), rect.width() - 1, rect.height());
	glEnable(GL_SCISSOR_TEST);

	// horizontal line
	glBegin(GL_LINES);
		glVertex3f(m_dBmScalePanRect.right() - 2, y, 4.0f);
		glVertex3f(rect.right() - 1, y, 4.0f);
	glEnd();

	// vertical line
	glBegin(GL_LINES);
		glVertex3f(x, rect.top() + 1, 4.0f);
		glVertex3f(x, rect.bottom() - 1, 4.0f);
	glEnd();

	// cross hair
	qglColor(QColor(255, 255, 255, 180));
	glBegin(GL_LINES);
		glVertex3f(x     , y - 20, 5.0f);
		glVertex3f(x     , y + 20, 5.0f);
		glVertex3f(x - 20, y, 5.0f);
		glVertex3f(x + 20, y, 5.0f);
	glEnd();

	// text only on panadapter
	//if (m_mouseRegion == panadapterRegion) {
		
	QString str;
	qglColor(QColor(255, 255, 255, 255));

	int dx = m_panRect.width()/2 - x;
	qreal unit = (qreal)((m_sampleRate * m_freqScaleZoomFactor) / m_panRect.width());
	qreal df = unit * dx;
	qreal frequency = m_frequency - df;
	
	str = frequencyString(-df, true);
	if (x > m_panRect.width() - 85)
		m_oglTextSmall->renderText(x -90, y - 30, 5.0f, str);
	else
		m_oglTextSmall->renderText(x + 4, y - 30, 5.0f, str);

	str = frequencyString(frequency);
	if (x > m_panRect.width() - 85)
		m_oglTextSmall->renderText(x - 90, y - 18, 5.0f, str);
	else
		m_oglTextSmall->renderText(x + 4, y - 18, 5.0f, str);

	if (m_mouseRegion == panadapterRegion) {

		qreal dBm = m_dBmPanMax - ((m_dBmPanMax - m_dBmPanMin) * ((qreal)(y - m_panRect.top()) / m_panRect.height()));
		str = QString::number(dBm, 'f', 1) + " dBm";
		if (x > m_panRect.width() - 85)
			m_oglTextSmall->renderText(x - 90, y + 6, 5.0f, str);
		else
			m_oglTextSmall->renderText(x + 4, y + 6, 5.0f, str);
	}

	// disable scissor box
	glDisable(GL_SCISSOR_TEST);

	glEnable(GL_MULTISAMPLE);
}

//************
void QGLDistancePanel::drawDistanceSpectrum() {

	//float yScale;
	//float yScaleColor;
	//float yTop;
	float localMax;

	GLint displayWidth = (GLint)m_distanceSpectrumRect.width();
	
	double distScale = 0;
	//freqScale = (float)m_sampleRate / rect.width();
	//distScale = 1024.0f / rect.width();
	
	distScale = (double)(1.0f * qRound(m_chirpBufferLength * m_distScaleZoomFactor) / m_distanceSpectrumRect.width());
	if (distScale < 1.0) distScale = 1.0;
	
	if (distScale < 0)	{

		drawGLRect(m_distanceSpectrumRect, Qt::black);
		//GRAPHICS_DEBUG << "drawDistanceSpectrum bad distance scale:" << distScale;
		return;
	}
	
	//qreal dBmRange = qAbs(dBmMax - dBmMin);
	qreal dBmRange = (m_dBmDistMax - m_dBmDistMin) * m_distScaleZoomFactor;

	float yScale = m_distanceSpectrumRect.height() / dBmRange;
	//float yScaleColor = 2.0f / dBmRange;
	float yTop = m_distanceSpectrumRect.top() + m_distanceSpectrumRect.height();
	
	int idx = 0;
	int lIdx = 0;
	int rIdx = 0;

	// set a scissor box
	glScissor(m_distanceSpectrumRect.left(), size().height() - m_distanceSpectrumRect.bottom() - 1, m_distanceSpectrumRect.left() + m_distanceSpectrumRect.width(), m_distanceSpectrumRect.height());
	glEnable(GL_SCISSOR_TEST);

	GLint vertexArrayLength = 0;
	
	/*if (m_vertexArray) {

		delete [] m_vertexArray;
		m_vertexArray = 0;
	}

	if (m_vertexColorArray) {

		delete [] m_vertexColorArray;
		m_vertexColorArray = 0;
	}*/

	glLineWidth(1);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	vertexArrayLength = displayWidth;
	TGL2float *vertexArray = new TGL2float[vertexArrayLength];
	TGL3float *vertexColorArray = new TGL3float[vertexArrayLength];

	//TGL3float *vertexArrayBg = new TGL3float[2*vertexArrayLength];
	//TGL3float *vertexColorArrayBg = new TGL3float[2*vertexArrayLength];

	//m_vertexArray = new TGL2float[vertexArrayLength];
	//m_vertexColorArray = new TGL3float[vertexArrayLength];

	m_redD = (GLfloat)(set->getPanadapterColors().distanceLineColor.red() / 256.0);
	m_greenD = (GLfloat)(set->getPanadapterColors().distanceLineColor.green() / 256.0);
	m_blueD = (GLfloat)(set->getPanadapterColors().distanceLineColor.blue() / 256.0);

	/*m_rf = (GLfloat)(set->getPanadapterColors().panLineFilledColor.red() / 256.0);
	m_gf = (GLfloat)(set->getPanadapterColors().panLineFilledColor.green() / 256.0);
	m_bf = (GLfloat)(set->getPanadapterColors().panLineFilledColor.blue() / 256.0);*/

	for (int i = 0; i < vertexArrayLength; i++) {
	
		lIdx = (int)floor((qreal)(i * distScale));
		rIdx = (int)floor((qreal)(i * distScale) + distScale);

		// max value; later we try mean value also!
		localMax = -10000.0F;
		for (int j = lIdx; j < rIdx; j++) {
			if (m_distanceSpectrumBuffer[j] > localMax) {

				localMax = m_distanceSpectrumBuffer[j];
				idx = j;
			}
		}

		/*m_spectrumVertexColorArrayBg[2*i].x = 0.10;
		m_spectrumVertexColorArrayBg[2*i].y = 0.20;
		m_spectrumVertexColorArrayBg[2*i].z = 0.25;*/

		vertexColorArray[i].x = m_redD;// * (yScaleColor * (m_distanceSpectrumBuffer[idx] - dBmMin));
		vertexColorArray[i].y = m_greenD;// * (yScaleColor * (m_distanceSpectrumBuffer[idx] - dBmMin));
		vertexColorArray[i].z = m_blueD;// * (yScaleColor * (m_distanceSpectrumBuffer[idx] - dBmMin));
		
		vertexArray[i].x = i;
		vertexArray[i].y = yTop - yScale * (m_distanceSpectrumBuffer[idx] - m_dBmDistMin);
	}
	
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
				
	glVertexPointer(2, GL_FLOAT, 0, vertexArray);
	glColorPointer(3, GL_FLOAT, 0, vertexColorArray);
	glDrawArrays(GL_LINE_STRIP, 0, vertexArrayLength);

	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_COLOR_ARRAY);

	delete[] vertexArray;
	delete[] vertexColorArray;
	
	// disable scissor box
	glDisable(GL_SCISSOR_TEST);
}

void QGLDistancePanel::drawDistHorizontalScale() {

	if (m_freqScaleDistancePanRect.isEmpty()) return;

	//QFontMetrics d_fm(m_smallFont);

	int rulerFontHeight;
	int rulerFontMaxWidth;
	double maxSpanDist;

	if (m_showChirpFFT) {

		rulerFontHeight = m_fonts.smallFontMetrics->tightBoundingRect(".0Hz").height();
		rulerFontMaxWidth = m_fonts.smallFontMetrics->boundingRect("000000").width();

		//maxSpanDist = m_sampleRate / 2;
		maxSpanDist = m_sampleRate / 4;
		//maxSpanDist = m_sampleRate;
	}
	else {

		rulerFontHeight = m_fonts.smallFontMetrics->tightBoundingRect(".0kmM").height();
		rulerFontMaxWidth = m_fonts.smallFontMetrics->boundingRect("0000000").width();

		maxSpanDist = m_chirpBufferLength * m_kilometersPerGate;
	}

	qreal kilometerSpan = maxSpanDist * m_distScaleZoomFactor;
	
	qreal lowerDist = 0;
	qreal upperDist = 0;

	if (m_showChirpFFT)
		lowerDist = -maxSpanDist/2;
	else {

		lowerDist = m_dBmDistDelta;
		if (lowerDist < 0.0) lowerDist = 0.0;
	}
	
	upperDist = lowerDist + kilometerSpan;
	if (upperDist > maxSpanDist) {
		
		upperDist = maxSpanDist;
		lowerDist = maxSpanDist - kilometerSpan;
	}

	qreal unit = (float)(m_freqScaleDistancePanRect.width() / kilometerSpan);
	
	m_distanceScale = getXRuler(m_freqScaleDistancePanRect, rulerFontMaxWidth, unit, lowerDist, upperDist);

	// draw the scale background
	drawGLScaleBackground(m_freqScaleDistancePanRect, Qt::black);

	// draw the distance scale
	int		offset_X		= -1;
	int		textOffset_y	= 17;
	double	distScale		= 1;

//	char *str;
//	if (m_showChirpFFT)
//		str = "  Hz ";
//	else
//		str = "  km ";
	
	QRect scaledTextRect(0, textOffset_y, 1, rulerFontHeight);
	//scaledTextRect.setWidth(d_fm.width(str));
	scaledTextRect.moveLeft(m_freqScaleDistancePanRect.width() - scaledTextRect.width());// - menu_pull_right_rect.width());
	
	glColor3f(0.94f, 0.22f, 0.43f);
	glRasterPos3f(m_freqScaleDistancePanRect.width() - 30, m_freqScaleDistancePanRect.top() + textOffset_y, 0.0);
	//writeBitmapString(GLUT_BITMAP_HELVETICA_10, str);

	if (m_mouseRegion == freqScaleDistancePanRegion)
		glColor3f(0.8f, 0.92f, 0.97f);
	else
		glColor3f(0.65f, 0.76f, 0.81f);

	int len = m_distanceScale.mainPointPositions.length();
	if (len > 0) {

		glLineWidth(3);
		glBegin(GL_LINES);
		for (int i = 0; i < len; i++) {

			glVertex3f(m_distanceScale.mainPointPositions.at(i), m_freqScaleDistancePanRect.top() + 1, 0.0f); // origin of the line
			glVertex3f(m_distanceScale.mainPointPositions.at(i), m_freqScaleDistancePanRect.top() + 4, 0.0f); // ending point of the line
		}
		glEnd();

		for (int i = 0; i < len; i++) {
		
			QString str = QString::number(m_distanceScale.mainPoints.at(i) / distScale, 'f', 0);

			int textWidth = m_fonts.smallFontMetrics->width(str);
			QRect textRect(m_distanceScale.mainPointPositions.at(i) + offset_X - (textWidth / 2), textOffset_y, textWidth, rulerFontHeight);

			QByteArray ba = str.toLatin1();
			char *cstr = ba.data();

			if (textRect.left() < 0 || textRect.right() >= scaledTextRect.left()) continue;

			glRasterPos3f(m_distanceScale.mainPointPositions.at(i) + offset_X - (textWidth / 2), m_freqScaleDistancePanRect.top() + textOffset_y, 0.0);
			m_oglTextSmall->renderText(textRect.x(), textRect.y(), cstr);
			//writeBitmapString(GLUT_BITMAP_HELVETICA_10, cstr);
		}
	}

	len = m_distanceScale.subPointPositions.length();
	if (len > 0) {

		glLineWidth(1);
		glBegin(GL_LINES);
		for (int i = 0; i < len; i++) {

			glVertex3f(m_distanceScale.subPointPositions.at(i), m_freqScaleDistancePanRect.top() + 1, 0.0f); // origin of the line
			glVertex3f(m_distanceScale.subPointPositions.at(i), m_freqScaleDistancePanRect.top() + 3, 0.0f); // ending point of the line
		}
		glEnd();
	}
}

void QGLDistancePanel::drawDistVerticalScale() {
		/*const QRect &rect,
		const QRect &distRect,
		int region,
		qreal dBmMin,
		qreal dBmMax,
		bool showZerodBmLine*/

	if (m_dBmScaleDistancePanRect.isEmpty()) return;

	//QFontMetrics d_fm(m_smallFont);
	int spacing = 5;
	int fontHeight = m_fonts.smallFontMetrics->tightBoundingRect(".0dBm").height() + spacing;
	int fontMaxWidth = m_fonts.smallFontMetrics->boundingRect("-000.0").width();

	qreal dBmRange = qAbs(m_dBmDistScaleMax - m_dBmDistScaleMin);
	//if (dBmRange <= 0) return;

	qreal unit = (float)(m_dBmScaleDistancePanRect.height() / dBmRange);

	m_dBmScale = getYRuler(m_dBmScaleDistancePanRect, fontHeight, unit, m_dBmDistScaleMin, m_dBmDistScaleMax);
	
	// draw the scale background
	drawGLScaleBackground(m_dBmScaleDistancePanRect, QColor(60, 60, 60, 80));

	QRect textRect(0, 0, fontMaxWidth, fontHeight);
	textRect.moveRight(14);
	int yOld = -textRect.height();
	
	if (m_mouseRegion == dBmScaleDistancePanRegion)
		glColor3f(0.8f, 0.92f, 0.97f);
	else
		glColor3f(0.65f, 0.76f, 0.81f);


	glLineWidth(1);
	int len = m_dBmScale.mainPointPositions.length();
	
	if (len > 0) {

		glBegin(GL_LINES);
		for (int i = 0; i < len; i++) {

			glVertex3f(m_dBmScaleDistancePanRect.left(),     m_dBmScale.mainPointPositions.at(i), 0.0f);	// origin of the line
			glVertex3f(m_dBmScaleDistancePanRect.left() + 4, m_dBmScale.mainPointPositions.at(i), 0.0f);	// ending point of the line
		}
		glEnd();

		for (int i = 0; i < len; i++) {

			textRect.moveTop(m_dBmScale.mainPointPositions.at(i) + textRect.height()/3);

			QString str;
			if (textRect.y() >= yOld && 
				textRect.bottom() <= (m_dBmScaleDistancePanRect.top() + m_dBmScaleDistancePanRect.height() - textRect.height()) &&
				m_dBmScale.mainPointPositions.at(i) > 10 + m_dBmScaleDistancePanRect.top())
			{
				str = QString::number(m_dBmScale.mainPoints.at(i), 'f', 1);
				QByteArray ba = str.toLatin1();
				//char *cstr = ba.data();
				glRasterPos3f(textRect.right() + m_dBmScaleDistancePanRect.left(), textRect.y(), 0.0);
				//writeBitmapString(GLUT_BITMAP_TIMES_ROMAN_10, cstr);
				yOld = textRect.bottom();
			}
		
			if (qRound(m_dBmScale.mainPoints.at(i)) == 0 && m_showZerodBmLine) {
		
				int zerodBmLine = m_dBmScale.mainPointPositions.at(i);
				if (zerodBmLine > m_dBmScaleDistancePanRect.top() && zerodBmLine < m_dBmScaleDistancePanRect.bottom()) {
		
					glColor3f(0.2f, 0.87f, 0.87f);
					glBegin(GL_LINES);
					glVertex3f(m_distanceSpectrumRect.left(), zerodBmLine, 0.0f);						// origin of the line
					glVertex3f(m_distanceSpectrumRect.width() - m_dBmScaleDistancePanRect.width() + 4, zerodBmLine, 0.0f);	// ending point of the line
					glEnd();

					if (m_mouseRegion == dBmScaleDistancePanRegion)
						glColor3f(0.8f, 0.92f, 0.97f);
					else
						glColor3f(0.65f, 0.76f, 0.81f);
				}
			}
		}
	}

	if (m_mouseRegion == dBmScaleDistancePanRegion)
		glColor3f(0.5f, 0.62f, 0.67f);
	else
		glColor3f(0.35f, 0.46f, 0.51f);

	if (m_dBmScale.subPointPositions.length() > 0) {

		glBegin(GL_LINES);
		for (int i = 0; i < m_dBmScale.subPointPositions.length(); i++) {

			glVertex3f(m_dBmScaleDistancePanRect.left(),     m_dBmScale.subPointPositions.at(i), 0.0f);	// origin of the line
			glVertex3f(m_dBmScaleDistancePanRect.left() + 2, m_dBmScale.subPointPositions.at(i), 0.0f);	// ending point of the line
		}
		glEnd();
	}

	//char* s = "dBm";
	textRect.moveTop(m_dBmScaleDistancePanRect.top() + m_dBmScaleDistancePanRect.height() - textRect.height());
	glColor3f(0.94f, 0.22f, 0.43f);
	//glRasterPos3f(textRect.left(), textRect.center().y(), 0.0);
	//glRasterPos3f(textRect.right() + right, textRect.center().y(), 0.0);
	glRasterPos3f(textRect.right() + m_dBmScaleDistancePanRect.left(), textRect.center().y(), 0.0);
	//writeBitmapString(GLUT_BITMAP_HELVETICA_10, s);
	
	//glPushMatrix();
	//	glTranslatef(0.0, 0.0, 0.0);
	//	//glRotatef(45.0, 0.0, 0.0, 1.0);
	//	glScalef(0.25, 0.25, 0.25);
	//	writeStrokeString(GLUT_STROKE_ROMAN, s);
	//glPopMatrix();
}

//**********************************************************************************************
// The algorithms of the scale functions renderPanVerticalScale() and renderPanHorizontalScale() 
// are taken from SDRMAXIII (c) Catherine Moss, with permission.

void QGLDistancePanel::renderPanVerticalScale() {

	QString str;
	//QFontMetrics d_fm(m_smallFont);
	//QFontMetrics d_fm(m_normalFont);

	int spacing = 7;
	int fontHeight = m_fonts.smallFontMetrics->tightBoundingRect(".0dBm").height() + spacing;
	int fontMaxWidth = m_fonts.smallFontMetrics->boundingRect("-000.0").width();

	GLint width = m_dBmScalePanRect.width();
	GLint height = m_dBmScalePanRect.height();

	qreal unit = (qreal)(m_dBmScalePanRect.height() / qAbs(m_dBmPanMax - m_dBmPanMin));

	m_dBmScale = getYRuler2(m_dBmScalePanRect, fontHeight, unit, m_dBmPanMin, m_dBmPanMax);

	glClear(GL_COLOR_BUFFER_BIT);
	
	QRect textRect(0, 0, fontMaxWidth, fontHeight);
	textRect.moveLeft(3);
	int yOld = -textRect.height();

	int len		= m_dBmScale.mainPointPositions.length();
	int sublen	= m_dBmScale.subPointPositions.length();
	
	glViewport(0, 0, width, height);
	setProjectionOrthographic(width, height);

	// draw the scale background
	drawGLScaleBackground(QRect(0, 0, width, height), QColor(30, 30, 30, 180));
	
	if (len > 0) {

		glColor3f(0.65f, 0.76f, 0.81f);
		glLineWidth(1);

		glBegin(GL_LINES);
		for (int i = 0; i < len; i++) {

			glVertex3f(width,     m_dBmScale.mainPointPositions.at(i), 0.0f);	// origin of the line
			glVertex3f(width - 4, m_dBmScale.mainPointPositions.at(i), 0.0f);	// ending point of the line
		}
		glEnd();
		
		glColor3f(0.45f, 0.56f, 0.61f);
		if (sublen > 0) {

			glBegin(GL_LINES);
			for (int i = 0; i < sublen; i++) {

				glVertex3f(width,     m_dBmScale.subPointPositions.at(i), 0.0f);	// origin of the line
				glVertex3f(width - 2, m_dBmScale.subPointPositions.at(i), 0.0f);	// ending point of the line
			}
			glEnd();
		}

		glColor3f(0.75f, 0.86f, 0.91f);
		for (int i = 0; i < len; i++) {

			textRect.moveBottom(m_dBmScale.mainPointPositions.at(i) + textRect.height()/2);
			
			if (textRect.y() >= yOld && textRect.bottom() <= (m_dBmScalePanRect.height() - textRect.height())) {
			
				str = QString::number(m_dBmScale.mainPoints.at(i), 'f', 1);
				m_oglTextSmall->renderText(textRect.x() + fontMaxWidth - m_fonts.smallFontMetrics->tightBoundingRect(str).width(), textRect.y(), str);
				yOld = textRect.bottom();
			}
		}
	}

	textRect.moveTop(m_dBmScalePanRect.height() - textRect.height());
	glColor3f(0.94f, 0.22f, 0.43f);
	
	str = QString("dBm");
	m_oglTextSmall->renderText(textRect.x(), textRect.y(), str);

	glViewport(0, 0, size().width(), size().height());
	setProjectionOrthographic(size().width(), size().height());
}

void QGLDistancePanel::renderPanHorizontalScale() {

	//GRAPHICS_DEBUG << "render frequency scale";
	//QFontMetrics d_fm(m_smallFont);
	int fontHeight = m_fonts.smallFontMetrics->tightBoundingRect(".0kMGHz").height();
	int fontMaxWidth = m_fonts.smallFontMetrics->boundingRect("000.000.0").width();

	qreal freqSpan = (qreal)(m_sampleRate * m_freqScaleZoomFactor);
	qreal lowerFreq = (qreal)m_frequency - freqSpan / 2;
	qreal upperFreq = (qreal)m_frequency + freqSpan / 2;
	qreal unit = (qreal)(m_freqScalePanRect.width() / freqSpan);

	m_frequencyScale = getXRuler(m_freqScalePanRect, fontMaxWidth, unit, lowerFreq, upperFreq);

	// draw the frequency scale
	int		offset_X		= -1;
	int		textOffset_y	= 5;
	double	freqScale		= 1;

	QString fstr = QString(" Hz ");
	if (upperFreq >= 1e6) { freqScale = 1e6; fstr = QString("  MHz "); }
	else
	if (upperFreq >= 1e3) { freqScale = 1e3; fstr = QString("  kHz "); }

	// draw the scale background
	drawGLScaleBackground(QRect(0, 0, m_freqScalePanRect.width(), m_freqScalePanRect.height()), QColor(0, 0, 0, 255));
	
	QRect scaledTextRect(0, textOffset_y, 1, m_freqScalePanRect.height());
	scaledTextRect.setWidth(m_fonts.smallFontMetrics->width(fstr));
	scaledTextRect.moveLeft(m_freqScalePanRect.width() - scaledTextRect.width());

	glColor3f(0.65f, 0.76f, 0.81f);
	int len = m_frequencyScale.mainPointPositions.length();
	if (len > 0) {

		glLineWidth(3);
		glBegin(GL_LINES);
		for (int i = 0; i < len; i++) {

			glVertex3f(m_frequencyScale.mainPointPositions.at(i), 1.0f, 0.0f);
			glVertex3f(m_frequencyScale.mainPointPositions.at(i), 4.0f, 0.0f);
		}
		glEnd();
		
		for (int i = 0; i < len; i++) {
		
			QString str = QString::number(m_frequencyScale.mainPoints.at(i) / freqScale, 'f', 3);
			
			if (i > 0) {

				double delta = m_frequencyScale.mainPoints.at(i) - m_frequencyScale.mainPoints.at(i-1);
				if (delta < 1000.0)
					str = QString::number(m_frequencyScale.mainPoints.at(i) / freqScale, 'f', 4);
				else
				if (freqScale == 1e3)
					while (str.endsWith('0')) str.remove(str.size() - 1, 1);
			}
			if (str.endsWith('.')) str.remove(str.size() - 1, 1);

			int text_width = m_fonts.smallFontMetrics->width(str);
			QRect textRect(m_frequencyScale.mainPointPositions.at(i) + offset_X - (text_width / 2), textOffset_y, text_width, fontHeight);

			if (textRect.left() < 0 || textRect.right() >= scaledTextRect.left()) continue;
			
			m_oglTextSmall->renderText(textRect.x(), textRect.y(), str);
		}
	}

	if (m_frequencyScale.subPointPositions.length() > 0) {

		glLineWidth(1);
		glBegin(GL_LINES);
		for (int i = 0; i < m_frequencyScale.subPointPositions.length(); i++) {

			glVertex3f(m_frequencyScale.subPointPositions.at(i), 1.0f, 0.0f);
			glVertex3f(m_frequencyScale.subPointPositions.at(i), 3.0f, 0.0f);
		}
		glEnd();
	}

	glColor3f(0.94f, 0.22f, 0.43f);
	m_oglTextSmall->renderText(m_freqScalePanRect.width() - 30, textOffset_y, fstr);
}

void QGLDistancePanel::renderPanadapterGrid() {

	//GRAPHICS_DEBUG << "render panadapter grid";
	//glLineStipple(1, 0xCCCC);
	glClear(GL_COLOR_BUFFER_BIT);
	glLineStipple(1, 0x9999);
	glEnable(GL_LINE_STIPPLE);
	glLineWidth(1.0f);

	// vertical lines
	int len = m_frequencyScale.mainPointPositions.length();
	if (len > 0) {

		GLint x1 = m_panRect.left();
		GLint x2 = 1;
		if (m_dBmScalePanRect.isValid()) x2 += m_dBmScalePanRect.width();

		//GLint y1 = rect.top() + 1;
		GLint y1 = 1;
		GLint y2 = m_panRect.bottom() - 1;

		TGL2int *vertexArray = new TGL2int[len * 2];
		int vertexArrayLen = 0;

		TGL2int point1, point2;
		point1.y = y1;
		point2.y = y2;
		for (int i = 0; i < len; i++) {

			GLint x = m_frequencyScale.mainPointPositions.at(i);
			if (x < x2) continue;
			x += x1;
			point1.x = x;
			point2.x = x;
			vertexArray[vertexArrayLen++] = point1;
			vertexArray[vertexArrayLen++] = point2;
		}

		glEnableClientState(GL_VERTEX_ARRAY);
		glVertexPointer(2, GL_INT, 0, vertexArray);
		glDrawArrays(GL_LINES, 0, vertexArrayLen);
		glDisableClientState(GL_VERTEX_ARRAY);

		delete[] vertexArray;
	}

	// horizontal lines
	len = m_dBmScale.mainPointPositions.length();
	if (len > 0) {

		TGL2float *vertexArray = new TGL2float[len * 2];
		int vertexArrayLen = 0;

		TGL2float point1, point2;
		point1.x = m_panRect.left() + m_dBmScalePanRect.width();
		point2.x = m_panRect.right();
		
		for (int i = 0; i < len; i++) {

			GLfloat y = m_dBmScale.mainPointPositions.at(i);
			
			point1.y = y;
			point2.y = y;
			
			vertexArray[vertexArrayLen++] = point1;
			vertexArray[vertexArrayLen++] = point2;
		}

		glEnableClientState(GL_VERTEX_ARRAY);
		glVertexPointer(2, GL_FLOAT, 0, vertexArray);
		glDrawArrays(GL_LINES, 0, vertexArrayLen);
		glDisableClientState(GL_VERTEX_ARRAY);

		delete[] vertexArray;

	}
	glDisable(GL_LINE_STIPPLE);
}
 

//********************************************************************

void QGLDistancePanel::getRegion(QPoint p) {

	QRect mouse_rect(0, 0, 100, 100);
	mouse_rect.moveCenter(p);

	if (m_freqScalePanRect.contains(p)) {

		m_mouseRegion = freqScalePanadapterRegion;
		
		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}
	else if (m_dBmScalePanRect.contains(p)) {

		m_mouseRegion = dBmScalePanadapterRegion;

		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}
	else if (abs(p.x() - m_filterRect.left()) < m_snapMouse &&
			 m_panRect.contains(p)
	) {
		m_mouseRegion = filterRegionLow;
		m_mouseDownFilterFrequencyLo = m_filterLowerFrequency;
	}

	else if (abs(p.x() - m_filterRect.right()) < m_snapMouse &&
			 m_panRect.contains(p)
	) {
		m_mouseRegion = filterRegionHigh;
		m_mouseDownFilterFrequencyHi = m_filterUpperFrequency;
	}

	else if (m_panRect.contains(p)) {

		m_mouseRegion = panadapterRegion;

		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}
	
	else if (m_freqScaleDistancePanRect.contains(p)) {		
		
		m_mouseRegion = freqScaleDistancePanRegion;
		m_distRulerUpdate = true;

		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}

	else if (m_dBmScaleDistancePanRect.contains(p)) {

		m_mouseRegion = dBmScaleDistancePanRegion;

		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}
	else if (m_distanceSpectrumRect.contains(p)) {

		m_mouseRegion = distancePanRegion;

		if (m_displayTime.elapsed() >= 50) {
			
			m_displayTime.restart();
			update();
		}
	}
	else
		m_mouseRegion = elsewhere;

	/*if (m_displayTime.elapsed() >= 50) {

		m_displayTime.restart();
		updateGL();
		update();
	}*/
	//GRAPHICS_DEBUG << "region" << m_mouseRegion;
}

void QGLDistancePanel::resizeGL(int iWidth, int iHeight) {

	int width = (int)(iWidth/2) * 2;
	int height = iHeight;

	if (width != m_oldWidth) {

		m_freqScalePanadapterRenew = true;
		m_panGridRenew = true;

		m_oldWidth = width;
	}

	m_spectrumVertexColorUpdate = true;
	//m_displayData.size = QSize(width, height);

	glFinish();

	m_resizeTime.restart();
	setupDisplayRegions(QSize(width, height));
    glViewport(0, 0, (GLsizei)width, (GLsizei)height);

	setProjectionOrthographic(width, height);
}

void QGLDistancePanel::setupDisplayRegions(QSize size) {

	m_displayTop = 0;
	int freqScaleRectHeight = 20;
	int dBmScaleWidth = 45;
	int distScaleRectHeight = 20;

	m_freqScalePanRect = QRect(
			0, 
			m_displayTop + qRound((size.height() - m_displayTop - freqScaleRectHeight) * m_freqRulerPosition), 
			size.width(), 
			freqScaleRectHeight);

	m_panRect = QRect(
			0,
			m_displayTop, 
			size.width(),
			m_freqScalePanRect.top() - m_displayTop);

	if (m_panRect.height() != m_oldPanRectHeight) {

		m_dBmScalePanadapterRenew = true;
		m_panGridRenew = true;
	}

	m_oldPanRectHeight = m_panRect.height();
	m_panRectWidth = (GLint)m_panRect.width();
	
	m_freqScaleDistancePanRect = QRect(
									0,
									size.height() - m_displayTop - distScaleRectHeight + 1, 
									size.width(),
									distScaleRectHeight);

	m_distanceSpectrumRect = QRect(
								m_freqScalePanRect.left(),
								m_freqScalePanRect.bottom(),
								m_freqScalePanRect.width(),
								size.height() - m_displayTop - m_freqScalePanRect.bottom() - distScaleRectHeight + 1);

	m_distancePanRect = QRect(
							m_freqScalePanRect.left(),
							m_freqScalePanRect.bottom(),
							m_freqScalePanRect.width(),
							size.height() - m_displayTop - m_freqScalePanRect.bottom() - distScaleRectHeight + 1);
					
	m_dBmScaleDistancePanRect = QRect(
									m_distanceSpectrumRect.right() - dBmScaleWidth, 
									m_freqScalePanRect.bottom(), 
									dBmScaleWidth, 
									size.height() - m_displayTop - m_freqScalePanRect.bottom() - distScaleRectHeight + 1);

	m_dBmScalePanRect = QRect(
						m_panRect.left(), 
						m_displayTop, 
						45, 
						m_panRect.height());

	m_freqScalePanadapterUpdate = true;
	m_dBmScalePanadapterUpdate = true;
	m_panGridUpdate = true;
	
	//***************************************************************************
	/*GRAPHICS_DEBUG << "***************************************************************************";
	GRAPHICS_DEBUG << "total size" << size.height();
	GRAPHICS_DEBUG << "sizes (top, bottom, height):";
	GRAPHICS_DEBUG << "panRect: " << m_panRect.top() << " " << m_panRect.bottom() << " " << m_panRect.height();
	GRAPHICS_DEBUG << "freqScalePanRect: " << m_freqScalePanRect.top() << " " << m_freqScalePanRect.bottom() << " " << m_freqScalePanRect.height();
	GRAPHICS_DEBUG << "dBmScalePanRect: " << m_dBmScalePanRect.top() << " " << m_dBmScalePanRect.bottom() << " " << m_dBmScalePanRect.height();
	GRAPHICS_DEBUG << "m_distanceSpectrumRect: " << m_distanceSpectrumRect.top() << " " << m_distanceSpectrumRect.bottom() << " " << m_distanceSpectrumRect.height();
	GRAPHICS_DEBUG << "m_freqScaleDistancePanRect: " << m_freqScaleDistancePanRect.top() << " " << m_freqScaleDistancePanRect.bottom() << " " << m_freqScaleDistancePanRect.height();
	GRAPHICS_DEBUG << "m_dBmScaleDistancePanRect: " << m_dBmScaleDistancePanRect.top() << " " << m_dBmScaleDistancePanRect.bottom() << " " << m_dBmScaleDistancePanRect.height();
	GRAPHICS_DEBUG << "";*/
}

void QGLDistancePanel::saveGLState() {

    glPushAttrib(GL_ALL_ATTRIB_BITS);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
}

void QGLDistancePanel::restoreGLState() {

    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glPopAttrib();
}
 
//********************************************************************
// HMI control
 
void QGLDistancePanel::enterEvent(QEvent *event) {

	setFocus(Qt::MouseFocusReason);

	m_mousePos = QPoint(-1, -1);
	m_mouseRegion = elsewhere;
	update();

	QGLWidget::enterEvent(event);
}

void QGLDistancePanel::leaveEvent(QEvent *event) {

	m_mousePos = QPoint(-1, -1);
	m_mouseRegion = elsewhere;
	update();

	QGLWidget::leaveEvent(event);
}

void QGLDistancePanel::wheelEvent(QWheelEvent* event) {
	
	//GRAPHICS_DEBUG << "wheelEvent";
	QPoint pos = event->pos();

	if (event->buttons() == Qt::NoButton) getRegion(pos);

	double freqStep = set->getMouseWheelFreqStep(0);

	switch (m_mouseRegion) {

		case panadapterRegion:

			double delta = 0;
			if (event->delta() < 0) delta = -freqStep;
			else
			if (event->delta() > 0) delta =  freqStep;

			if (m_frequency + delta > MAXFREQUENCY)
				m_frequency = MAXFREQUENCY;
			else
			if (m_frequency + delta < 0)
				m_frequency = 0;
			else
				// snap to the frequency step
				m_frequency = (long)(qRound((m_frequency + delta) / qAbs(freqStep)) * qAbs(freqStep));

			//set->setFrequency(this, true, 0, m_frequency);
			set->setVFOFrequency(this, 0, 0, m_frequency);

			/*if (m_spectrumAveragingOld) {

				m_spectrumAveragingOld = true;
				m_spectrumAveraging = false;

				freqChangeTimer.restart();
			}*/
			break;
	}

 	//updateGL();
	update();
}

void QGLDistancePanel::mousePressEvent(QMouseEvent* event) {
	
	//GRAPHICS_DEBUG << "mousePressEvent";
	m_mousePos = event->pos();
	m_mouseDownPos = m_mousePos;

	getRegion(m_mousePos);

	if (m_mouseRegion == panadapterRegion) {

		if (event->buttons() == Qt::RightButton) {

			if (m_crossHairCursor) {

				m_crossHairCursor = false;
				setCursor(Qt::ArrowCursor);
			}
			else {

				m_crossHairCursor = true;
				setCursor(Qt::BlankCursor);
			}	
		}
		else if (event->buttons() == Qt::LeftButton && m_crossHairCursor) {

			double freqStep = set->getMouseWheelFreqStep(0);
			int dx = m_panRect.width()/2 - m_mousePos.x();
			qreal unit = (qreal)((m_sampleRate * m_freqScaleZoomFactor) / m_panRect.width());
			m_frequency -= unit * dx;

			m_frequency = (long)(qRound(m_frequency / qAbs(freqStep)) * qAbs(freqStep));
				
			//set->setFrequency(this, true, 0, m_frequency);
			set->setVFOFrequency(this, 0, 0, m_frequency);
			update();
		}
	}
	else if (m_mouseRegion == freqScalePanadapterRegion) {

		m_rulerMouseDownPos = m_freqScalePanRect.topLeft();
		
		if (event->buttons() == Qt::RightButton) setCursor(Qt::SplitHCursor);
		update();

		return;
	}
	else if (m_mouseRegion == freqScaleDistancePanRegion) {

		m_rulerMouseDownPos = m_freqScaleDistancePanRect.topLeft();
		
		if (event->buttons() == Qt::RightButton) setCursor(Qt::SplitHCursor);
		update();

		return;
	}
	else if (m_mouseRegion == dBmScalePanadapterRegion) {

		m_rulerMouseDownPos = m_dBmScaleDistancePanRect.topLeft();

		if (event->buttons() == Qt::RightButton) setCursor(Qt::SplitVCursor);
		update();

		return;
	}
	else if (m_mouseRegion == dBmScaleDistancePanRegion) {

		m_rulerMouseDownPos = m_dBmScaleDistancePanRect.topLeft();

		if (event->buttons() == Qt::RightButton) setCursor(Qt::SplitVCursor);
		update();

		return;
	}
	
 	update();
}

void QGLDistancePanel::mouseReleaseEvent(QMouseEvent *event) {

	//GRAPHICS_DEBUG << "mouseReleaseEvent";
	m_mousePos = event->pos();
	m_mouseDownPos = m_mousePos;

	getRegion(m_mousePos);

	if (m_mouseRegion == freqScalePanadapterRegion) {

		return;
	}
	else if (m_mouseRegion == freqScaleDistancePanRegion) {

		return;
	}
	else if (m_mouseRegion == dBmScaleDistancePanRegion) {

		if (event->button() == Qt::LeftButton && m_showZerodBmLine) {

			m_showZerodBmLine = false;
		}
		else if (event->button() == Qt::RightButton) {
		}
		update();
		return;
	}
 	update();
}

void QGLDistancePanel::mouseMoveEvent(QMouseEvent* event) {
	
	//GRAPHICS_DEBUG << "mouseMoveEvent";
	QPoint pos = event->pos();
	m_mousePos = event->pos();

	if (event->buttons() == Qt::NoButton) getRegion(pos);

	switch (m_mouseRegion) {

		case distancePanRegion:
			//GRAPHICS_DEBUG << "distancePanRegion";
			setCursor(Qt::ArrowCursor);
			//update();
			break;

		case panadapterRegion:
			//GRAPHICS_DEBUG << "panadapterRegion Rx:" << m_receiver;
			if (m_crossHairCursor)
				setCursor(Qt::BlankCursor);
			else
				setCursor(Qt::ArrowCursor);

			if (event->buttons() == Qt::LeftButton) {

				QPoint dPos = m_mouseDownPos - pos;
				
				qreal unit = (qreal)((m_sampleRate * m_freqScaleZoomFactor) / m_freqScalePanRect.width());
				qreal deltaFreq = unit * dPos.x();
				
				long newFrequency = m_frequency + deltaFreq;
				if (newFrequency > MAXFREQUENCY)
					newFrequency = MAXFREQUENCY;
				else
				if (newFrequency + deltaFreq < 0)
					newFrequency = 0;
				else
					m_frequency += deltaFreq;

				//set->setFrequency(this, true, 0, m_frequency);
				set->setVFOFrequency(this, 0, 0, m_frequency);
				m_mouseDownPos = pos;
			}
			//update();
			break;

		case dBmScalePanadapterRegion:
			//GRAPHICS_DEBUG << "dBmScalePanadapterRegion";
			if (event->buttons() == Qt::LeftButton) {

				QPoint dPos = m_mouseDownPos - pos;
				qreal unit = (qreal)(qAbs(m_dBmPanMax - m_dBmPanMin) / m_panRect.height());
				
				qreal newMin = m_dBmPanMin - unit * dPos.y();
				qreal newMax = m_dBmPanMax - unit * dPos.y();

				if (newMin > MINDBM && newMax < MAXDBM) {

					m_dBmPanMin = newMin;
					m_dBmPanMax = newMax;

					set->setdBmPanScaleMin(0, m_dBmPanMin);
					set->setdBmPanScaleMax(0, m_dBmPanMax);
				}
				
				m_mouseDownPos = pos;
				m_dBmScalePanadapterUpdate = true;
				m_panGridUpdate = true;
			}
			else
			if (event->buttons() == Qt::RightButton) {

				QPoint dPos = m_mouseDownPos - pos;
				if (dPos.y() > 0)
					m_dBmPanDelta = 1.0;
				else if (dPos.y() < 0)
					m_dBmPanDelta = -1.0f;
				
				m_dBmPanMin += m_dBmPanDelta;
				m_dBmPanMax -= m_dBmPanDelta;

				if (qAbs(m_dBmPanMax - m_dBmPanMin) < 10) {

					m_dBmPanMin -= m_dBmPanDelta;
					m_dBmPanMax += m_dBmPanDelta;
				}
				if (m_dBmPanMin < MINDBM) m_dBmPanMin = MINDBM;
				if (m_dBmPanMax > MAXDBM) m_dBmPanMax = MAXDBM;

				set->setdBmPanScaleMin(0, m_dBmPanMin);
				set->setdBmPanScaleMax(0, m_dBmPanMax);

				m_mouseDownPos = pos;
				m_dBmScalePanadapterUpdate = true;
				m_panGridUpdate = true;
			}
			else
				setCursor(Qt::ArrowCursor);

			//update();
			break;

		case dBmScaleDistancePanRegion:
			//GRAPHICS_DEBUG << "dBmScaleDistancePanRegion";
			if (event->buttons() == Qt::LeftButton &&
				event->modifiers() == Qt::ControlModifier) {

				m_showZerodBmLine = true;
				QPoint dPos = m_mouseDownPos - pos;

				qreal unit = (qreal)(qAbs(m_dBmDistScaleMax - m_dBmDistScaleMin) / m_distanceSpectrumRect.height());
				
				qreal newMin = m_dBmDistScaleMin - unit * dPos.y();
				qreal newMax = m_dBmDistScaleMax - unit * dPos.y();

				if (newMin > MINDISTDBM && newMax < MAXDISTDBM) {

					m_dBmDistScaleMin = newMin;
					m_dBmDistScaleMax = newMax;
				}
				m_mouseDownPos = pos;
			}
			else
			if (event->buttons() == Qt::LeftButton) {

				QPoint dPos = m_mouseDownPos - pos;

				qreal unit = (qreal)(qAbs(m_dBmDistMax - m_dBmDistMin) / m_distanceSpectrumRect.height());
				
				qreal newMin = m_dBmDistMin - unit * dPos.y();
				qreal newMax = m_dBmDistMax - unit * dPos.y();

				if (newMin > MINDISTDBM && newMax < MAXDISTDBM) {

					m_dBmDistMin = newMin;
					m_dBmDistMax = newMax;
				}
				m_mouseDownPos = pos;

				m_dBmDistScaleMin = m_dBmDistMin;
				m_dBmDistScaleMax = m_dBmDistMax;
			}
			else
			if (event->buttons() == Qt::RightButton) {

				QPoint dPos = m_mouseDownPos - pos;
				if (dPos.y() > 0)
					m_dBmDistDelta = 1.0;
				else if (dPos.y() < 0)
					m_dBmDistDelta = -1.0f;
				
				m_dBmDistMin += m_dBmDistDelta;
				m_dBmDistMax -= m_dBmDistDelta;

				if (qAbs(m_dBmDistMax - m_dBmDistMin) < 10) {

					m_dBmDistMin -= m_dBmDistDelta;
					m_dBmDistMax += m_dBmDistDelta;
				}
				if (m_dBmDistMin < MINDISTDBM) m_dBmDistMin = MINDISTDBM;
				if (m_dBmDistMax > MAXDISTDBM)  m_dBmDistMax =  MAXDISTDBM;

				m_dBmDistScaleMin = m_dBmDistMin;
				m_dBmDistScaleMax = m_dBmDistMax;
				
				m_mouseDownPos = pos;
			}
			else
				setCursor(Qt::ArrowCursor);
			//update();
			break;

		case freqScalePanadapterRegion:
			//GRAPHICS_DEBUG << "freqScalePanadapterRegion Rx" << m_receiver;
			if (event->buttons() == Qt::LeftButton) {
				
				QPoint dPos = m_mouseDownPos - pos;
				int bottom_y = height() - m_freqScalePanRect.height();
				int new_y = m_rulerMouseDownPos.y() - dPos.y();
				
				if (new_y < m_panRect.top() + m_panSpectrumMinimumHeight) 
					new_y = m_panRect.top() + m_panSpectrumMinimumHeight;
				if (new_y > bottom_y) 
					new_y = bottom_y;
				
				m_freqRulerPosition = (float)(new_y - m_panRect.top()) / (bottom_y - m_panRect.top());
				set->setFreqRulerPosition(this, 0, m_freqRulerPosition);
			}
			else
			if (event->buttons() == Qt::RightButton) {

				QPoint dPos = m_mouseDownPos - pos;
				if (dPos.x() > 0)
					m_freqScaleZoomFactor += 0.01;
				else if (dPos.x() < 0)
					m_freqScaleZoomFactor -= 0.01;

				if (m_freqScaleZoomFactor > 1.0) m_freqScaleZoomFactor = 1.0;
				//if (m_freqScaleZoomFactor < 0.05) m_freqScaleZoomFactor = 0.05;
				if (m_freqScaleZoomFactor < 0.15) m_freqScaleZoomFactor = 0.15;

				m_mouseDownPos = pos;
				m_freqScalePanadapterUpdate = true;
				m_panGridUpdate = true;
			}
			else
				setCursor(Qt::ArrowCursor);

			//update();
			break;

		case freqScaleDistancePanRegion:
			//GRAPHICS_DEBUG << "freqScaleDistancePanRegion";
			if (event->buttons() == Qt::LeftButton) {

				if (m_distScaleZoomFactor < 1.0) {
					QPoint dPos = m_mouseDownPos - pos;
					if (dPos.x() > 0)
						m_distRulerDisplayDelta += m_distRulerDisplayDeltaStep;
					else if (dPos.x() < 0)
						m_distRulerDisplayDelta -= m_distRulerDisplayDeltaStep;

					if (m_distRulerDisplayDelta < 0)
						m_distRulerDisplayDelta = 0.0;

					if (m_distRulerDisplayDelta > m_chirpBufferLength * m_kilometersPerGate)
						m_distRulerDisplayDelta -= m_distRulerDisplayDeltaStep;

					m_mouseDownPos = pos;
				}
				else
					m_distRulerDisplayDelta = 0.0;
			}
			else if (event->buttons() == Qt::RightButton) {
				
				QPoint dPos = m_mouseDownPos - pos;
				if (dPos.x() > 0)
					m_distScaleZoomFactor += 0.005;
				else if (dPos.x() < 0)
					m_distScaleZoomFactor -= 0.005;

				if (m_distScaleZoomFactor > 1.0) m_distScaleZoomFactor = 1.0;
				if (m_distScaleZoomFactor < 0.1) m_distScaleZoomFactor = 0.1;

				m_mouseDownPos = pos;
			}
			else
				setCursor(Qt::ArrowCursor);

			//update();
			break;

		case filterRegionLow:

			setCursor(Qt::SizeHorCursor);
			if (event->buttons() == Qt::LeftButton) {

				QPoint dPos = m_mouseDownPos - pos;
				qreal dFreq = (qreal)(dPos.x() * m_sampleRate * m_freqScaleZoomFactor) / m_panRect.width();

				m_filterLowerFrequency = qRound(m_mouseDownFilterFrequencyLo - dFreq);
				set->setRXFilter(this, 0, m_filterLowerFrequency, m_filterUpperFrequency);
			}
			break;

		case filterRegionHigh:

			setCursor(Qt::SizeHorCursor);
			if (event->buttons() == Qt::LeftButton) {

				QPoint dPos = m_mouseDownPos - pos;
				qreal dFreq = (qreal)(dPos.x() * m_sampleRate * m_freqScaleZoomFactor) / m_panRect.width();

				m_filterUpperFrequency = qRound(m_mouseDownFilterFrequencyHi - dFreq);
				set->setRXFilter(this, 0, m_filterLowerFrequency, m_filterUpperFrequency);
			}
			break;

		case elsewhere:
			//GRAPHICS_DEBUG << "elsewhere";
			
			//update();
			break;
	}

	if (m_displayTime.elapsed() >= 50) {

		m_displayTime.restart();
		update();
	}
	//setupDisplayRegions(size());
	//update();

	//locker.unlock();
}

void QGLDistancePanel::keyPressEvent(QKeyEvent* event) {
	
	//GRAPHICS_DEBUG << "keyPressEvent";
	if (event->key() == Qt::Key_Control) {
		
		//m_keyCTRLpressed = true;
		//GRAPHICS_DEBUG << "m_keyCTRLpressed =" << m_keyCTRLpressed;
		//printf("Ry %f\n",ry);
		//ry+=10.0f;
 	}
	else if (event->key() == Qt::Key_T) {
			
			//printf("Ry %f\n",ry);
			//ry-=10.0f;
	}
 	else if (event->key() == Qt::Key_P) {
		
		//drawTeapot = !drawTeapot;
	}
 	else if (event->key() == Qt::Key_W) {
		
		//approach -= 0.1f;
	}
 	else if (event->key() == Qt::Key_S) {
		
		//approach += 0.1f;
	}
	else {
		
		//m_keyCTRLpressed = false;
		//GRAPHICS_DEBUG << "m_keyCTRLpressed =" << m_keyCTRLpressed;
		//event->ignore();
 	}

	QWidget::keyPressEvent(event);
 	//updateGL();
	update();
}

void QGLDistancePanel::timerEvent(QTimerEvent *) {
	
	update();
}
 
//********************************************************************
 
void QGLDistancePanel::setFrequency(QObject *sender, bool value, long freq) {

	Q_UNUSED(sender)
	Q_UNUSED(value)
	
	m_frequency = freq;
	//m_displayData.frequency = freq;
	m_freqScalePanadapterUpdate = true;
	m_panGridUpdate = true;

	//updateGL();
	update();
}

void QGLDistancePanel::setFilterFrequencies(QObject *sender, int rx, qreal lo, qreal hi) {

	Q_UNUSED(sender)

	if (rx == 0) {
		
		m_filterLowerFrequency = lo;
		m_filterUpperFrequency = hi;
	}

	update();
}

void QGLDistancePanel::freqRulerPositionChanged(float pos, int rx) {

	if (rx == 0) {
		
		m_freqRulerPosition = pos;

		setupDisplayRegions(size());
		update();
	}
}

void QGLDistancePanel::setSpectrumBuffer(const float *buffer) {

	if (m_spectrumAveraging) {
	
		QVector<float>	m_specBuf(SAMPLE_BUFFER_SIZE);

		//spectrumBufferMutex.lock();

		memcpy(
			(float *) m_specBuf.data(),
			(float *) &buffer[0],
			SAMPLE_BUFFER_SIZE * sizeof(float));

		specAv_queue.enqueue(m_specBuf);
		if (specAv_queue.size() <= m_specAveragingCnt) {
	
			for (int i = 0; i < SAMPLE_BUFFER_SIZE; i++)
				m_tmpBuf[i] += specAv_queue.last().data()[i];

			//spectrumBufferMutex.unlock();
			return;
		}
	
		for (int i = 0; i < SAMPLE_BUFFER_SIZE; i++) {

				m_tmpBuf[i] -= specAv_queue.first().at(i);
				m_tmpBuf[i] += specAv_queue.last().at(i);
				m_avgBuf[i] = m_tmpBuf[i] * m_scale;
		}

		computeDisplayBins(m_avgBuf);
		specAv_queue.dequeue();
	
		//spectrumBufferMutex.unlock();
	}
	else
		computeDisplayBins(buffer);
}

void QGLDistancePanel::computeDisplayBins(const float *panBuffer) {

	int newSampleSize = 0;
	int deltaSampleSize = 0;
	int idx = 0;
	int lIdx = 0;
	int rIdx = 0;
	qreal localMax;

	if (m_serverMode == QSDR::ChirpWSPRFile) {
		
		newSampleSize = (int)floor(2 * BUFFER_SIZE * m_freqScaleZoomFactor);
		deltaSampleSize = 2 * BUFFER_SIZE - newSampleSize;
	}
	else {

		newSampleSize = (int)floor(4 * BUFFER_SIZE * m_freqScaleZoomFactor);
		deltaSampleSize = 4 * BUFFER_SIZE - newSampleSize;
	}

	/*if (deltaSampleSize%2 != 0) {
		deltaSampleSize += 1;
		newSampleSize -= 1;
	}*/

	m_panScale = (qreal)(1.0 * newSampleSize / m_panRectWidth);
	m_scaleMultOld = m_scaleMult;
		
	if (m_panScale < 0.125) {
		m_scaleMult = 0.0625;
	}
	else if (m_panScale < 0.25) {
		m_scaleMult = 0.125;
	}
	else if (m_panScale < 0.5) {
		m_scaleMult = 0.25;
	}
	else if (m_panScale < 1.0) {
		m_scaleMult = 0.5;
	}
	else {
		m_scaleMult = 1.0;
	}

	m_panSpectrumBinsLength = (GLint)(m_scaleMult * m_panRectWidth);

	/*if (bins != binsOld) {

		GRAPHICS_DEBUG << "newSampleSize" << newSampleSize;
		GRAPHICS_DEBUG << "m_panScale" << m_panScale;
		GRAPHICS_DEBUG << "bins:" << bins;
	}*/

	m_panadapterBins.clear();
	
	for (int i = 0; i < m_panSpectrumBinsLength; i++) {
			
		idx = 0;
		lIdx = (int)floor((qreal)(i * m_panScale / m_scaleMult));
		rIdx = (int)floor((qreal)(i * m_panScale / m_scaleMult) + m_panScale / m_scaleMult);
					
		// max value; later we try mean value also!
		localMax = -10000.0F;
		for (int j = lIdx; j < rIdx; j++) {

			if (panBuffer[j] > localMax) {

				localMax = panBuffer[j];
				idx = j;
			}
		}
		idx += deltaSampleSize/2;
				
		m_panadapterBins << panBuffer[idx] - m_dBmPanMin - m_dBmPanLogGain;
	}
	update();	
}

void QGLDistancePanel::setDistanceSpectrumBuffer(int sampleRate, qint64 length, const float *buffer) {

	Q_UNUSED(sampleRate)
	Q_UNUSED(length)
	Q_UNUSED(buffer)
}

void QGLDistancePanel::distanceSpectrumBufferChanged(int sampleRate, qint64 length, const float *buffer) {

	Q_UNUSED(sampleRate)

	distanceSpectrumBufferMutex.lock();
		m_kilometersPerGate = 1.0f * 3E5 / sampleRate;
		//m_kilometersPerGate = 0.5f * 3E5 / 12000;
		m_chirpBufferLength = length;
		memcpy(m_distanceSpectrumBuffer, buffer, m_chirpBufferLength * sizeof(float));
	distanceSpectrumBufferMutex.unlock();

	update();
}

// get waterfall colors - taken from PowerSDR/KISS Konsole
//QColor QGLDistancePanel::getWaterfallColorAtPixel(qreal value) {
//
//	QColor color;
//	//int r = 0; int g = 0; int b = 0;
//	int r, g, b;
//	int lowerThreshold = (int)m_dBmPanMin - m_waterfallOffsetLo;
//	int upperThreshold = (int)m_dBmPanMax + m_waterfallOffsetHi;
//
//	float offset;
//	float globalRange;
//	float localRange;
//	float percent;
//	
//	switch (m_waterColorScheme) {
//
//		case QSDRGraphics::simple:
//
//			if (value <= lowerThreshold)
//				color = m_waterfallLoColor;
//			else 
//			if (value >= upperThreshold)
//					color = QColor(255, 255, 255);//m_waterfallHiColor;
//			else {
//
//				percent = (value - lowerThreshold) / (upperThreshold - lowerThreshold);
//				if (percent <= 0.5)	{ // use a gradient between low and mid colors
//				
//					percent *= 2;
//
//					r = (int)((1 - percent) * m_waterfallLoColor.red()   + percent * m_waterfallMidColor.red());
//					g = (int)((1 - percent) * m_waterfallLoColor.green() + percent * m_waterfallMidColor.green());
//					b = (int)((1 - percent) * m_waterfallLoColor.blue()  + percent * m_waterfallMidColor.blue());
//				}
//				else {	// use a gradient between mid and high colors
//
//					percent = (float)(percent - 0.5) * 2;
//
//					r = (int)((1 - percent) * m_waterfallMidColor.red()   + percent * 255);//m_waterfallHiColor.red());
//					g = (int)((1 - percent) * m_waterfallMidColor.green() + percent * 255);//m_waterfallHiColor.green());
//					b = (int)((1 - percent) * m_waterfallMidColor.blue()  + percent * 255);//m_waterfallHiColor.blue());
//				}
//
//				if (r > 255) r = 255;
//				if (g > 255) g = 255;
//				if (b > 255) b = 255;
//				color = QColor(r, g, b, m_waterfallAlpha);
//			}
//
//			break;
//
//		case QSDRGraphics::enhanced:
//
//			if (value <= lowerThreshold)
//				color = m_waterfallLoColor;
//			else 
//			if (value >= upperThreshold)
//					color = m_waterfallHiColor;
//			else {
//
//				offset = value - lowerThreshold;
//				globalRange = offset / m_waterfallColorRange; // value from 0.0 to 1.0 where 1.0 is high and 0.0 is low.
//
//				if (globalRange < (float)2/9) { // background to blue
//
//					localRange = globalRange / ((float)2/9);
//					r = (int)((1.0 - localRange) * m_waterfallLoColor.red());
//					g = (int)((1.0 - localRange) * m_waterfallLoColor.green());
//					b = (int)(m_waterfallLoColor.blue() + localRange * (255 - m_waterfallLoColor.blue()));
//				}
//				else 
//				if (globalRange < (float)3/9) { // blue to blue-green
//
//					localRange = (globalRange - (float)2/9) / ((float)1/9);
//					r = 0;
//					g = (int)(localRange * 255);
//					b = 255;
//				}
//				else 
//				if (globalRange < (float)4/9) { // blue-green to green
//
//					localRange = (globalRange - (float)3/9) / ((float)1/9);
//					r = 0;
//					g = 255;
//					b = (int)((1.0 - localRange) * 255);
//				}
//				else 
//				if (globalRange < (float)5/9) { // green to red-green
//
//					localRange = (globalRange - (float)4/9) / ((float)1/9);
//					r = (int)(localRange * 255);
//					g = 255;
//					b = 0;
//				}
//				else 
//				if (globalRange < (float)7/9) { // red-green to red
//
//					localRange = (globalRange - (float)5/9) / ((float)2/9);
//					r = 255;
//					g = (int)((1.0 - localRange) * 255);
//					b = 0;
//				}
//				else 
//				if (globalRange < (float)8/9) { // red to red-blue
//
//					localRange = (globalRange - (float)7/9) / ((float)1/9);
//					r = 255;
//					g = 0;
//					b = (int)(localRange * 255);
//				}
//				else { // red-blue to purple end
//
//					localRange = (globalRange - (float)8/9) / ((float)1/9);
//					r = (int)((0.75 + 0.25 * (1.0 - localRange)) * 255);
//					g = (int)(localRange * 255 * 0.5);
//					b = 255;
//				}
//				if (r > 255) r = 255;
//				if (g > 255) g = 255;
//				if (b > 255) b = 255;
//				if (r < 0) r = 0;
//				if (g < 0) g = 0;
//				if (b < 0) b = 0;
//				color = QColor(r, g, b, m_waterfallAlpha);
//			}
//
//			break;
//
//		case QSDRGraphics::spectran:
//
//			break;
//	}
//	
//	return color;
//}

void QGLDistancePanel::setChirpFFTShow(bool value) {

	distanceSpectrumBufferMutex.lock();
		m_showChirpFFT = value;
	distanceSpectrumBufferMutex.unlock();

	update();
}
 
void QGLDistancePanel::systemStateChanged(
	QObject *sender, 
	QSDR::_Error err, 
	QSDR::_HWInterfaceMode hwmode, 
	QSDR::_ServerMode mode, 
	QSDR::_DataEngineState state)
{
	Q_UNUSED (sender)
	Q_UNUSED (err)
	Q_UNUSED (hwmode)
	Q_UNUSED (state)

	if (m_dataEngineState != state)
		m_dataEngineState = state;

	if (m_serverMode != mode) {

		//memset(m_wbSpectrumBuffer, -10000, 4 * BUFFER_SIZE * sizeof(float));
		memset(m_spectrumBuffer, -10000, 4 * BUFFER_SIZE * sizeof(float));
		memset(m_distanceSpectrumBuffer, -10000, 16 * BUFFER_SIZE * sizeof(float));
		m_serverMode = mode;
	}

	//resizeGL(width(), height());
	m_displayTime.restart();
	
	update();
}

 
void QGLDistancePanel::graphicModeChanged(
	QObject *sender,
	int rx,
	PanGraphicsMode panMode,
	WaterfallColorMode colorScheme)
{
	Q_UNUSED (sender)
	Q_UNUSED (colorScheme)
	Q_UNUSED (rx)

	if (m_panMode != panMode)
		m_panMode = panMode;

	/*if (m_waterColorScheme != colorScheme) {

		m_waterColorScheme = colorScheme;
		change = true;
	}*/

	//if (!change) return;

	update();
}

 void QGLDistancePanel::setSpectrumAveraging(bool value) {

	 spectrumBufferMutex.lock();

	 if (m_spectrumAveraging == value) 
		 return;
	 else
		 m_spectrumAveraging = value;

	 spectrumBufferMutex.unlock();
 }

void QGLDistancePanel::setSpectrumAveragingCnt(int value) {

	spectrumBufferMutex.lock();

		memset(m_tmpBuf, 0, SAMPLE_BUFFER_SIZE * sizeof(float));

		while (!specAv_queue.isEmpty())
			specAv_queue.dequeue();

		m_specAveragingCnt = value;

		if (m_specAveragingCnt > 0)
			m_scale = 1.0f / m_specAveragingCnt;
		else
			m_scale = 1.0f;

	spectrumBufferMutex.unlock();
}

void QGLDistancePanel::setPanGridStatus(bool value) {

	spectrumBufferMutex.lock();

	 if (m_panGrid == value) 
		 return;
	 else
		 m_panGrid = value;

	 spectrumBufferMutex.unlock();

	 update();
}

void QGLDistancePanel::sampleRateChanged(QObject *sender, int value) {

	Q_UNUSED(sender)
	
	m_sampleRate = value;
	update();
}

void QGLDistancePanel::setPanadapterColors() {

	m_spectrumColorsChanged = true;

	mutex.lock();
	/*m_bkgRed   = (GLfloat)(set->getPanadapterColors().panBackgroundColor.red() / 256.0);
	m_bkgGreen = (GLfloat)(set->getPanadapterColors().panBackgroundColor.green() / 256.0);
	m_bkgBlue  = (GLfloat)(set->getPanadapterColors().panBackgroundColor.blue() / 256.0);*/

	/*if (m_bkgRed * 1.2 > 1.0) m_bkgRed = 1.0f;
	if (m_bkgGreen * 1.2 > 1.0) m_bkgGreen = 1.0f;
	if (m_bkgBlue * 1.2 > 1.0) m_bkgBlue = 1.0f;

	if (m_bkgRed * 1.6 > 1.0) m_bkgRed = 1.0f;
	if (m_bkgGreen * 1.6 > 1.0) m_bkgGreen = 1.0f;
	if (m_bkgBlue * 1.6 > 1.0) m_bkgBlue = 1.0f;*/

	m_red	= (GLfloat)(set->getPanadapterColors().panLineColor.red() / 256.0);
	m_green = (GLfloat)(set->getPanadapterColors().panLineColor.green() / 256.0);
	m_blue	= (GLfloat)(set->getPanadapterColors().panLineColor.blue() / 256.0);

	m_redF	 = (GLfloat)(set->getPanadapterColors().panLineFilledColor.red() / 256.0);
	m_greenF = (GLfloat)(set->getPanadapterColors().panLineFilledColor.green() / 256.0);
	m_blueF  = (GLfloat)(set->getPanadapterColors().panLineFilledColor.blue() / 256.0);

	m_redST	  = (GLfloat)(set->getPanadapterColors().panSolidTopColor.red() / 256.0);
	m_greenST = (GLfloat)(set->getPanadapterColors().panSolidTopColor.green() / 256.0);
	m_blueST  = (GLfloat)(set->getPanadapterColors().panSolidTopColor.blue() / 256.0);

	m_redSB   = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.red() / 256.0);
	m_greenSB = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.green() / 256.0);
	m_blueSB  = (GLfloat)(set->getPanadapterColors().panSolidBottomColor.blue() / 256.0);

	mutex.unlock();

	update();
}

//void QGLDistancePanel::setWaterfallTime(int rx, int value) {
//
//	if (rx == 0)
//		m_waterfallTime = value;
//}

//void QGLDistancePanel::setWaterfallOffesetLo(int rx, int value) {
//
//	if (rx == 0)
//		m_waterfallOffsetLo = value;
//	
//	update();
//}
//
//void QGLDistancePanel::setWaterfallOffesetHi(int rx, int value) {
//
//	if (rx = 0)
//		m_waterfallOffsetHi = value;
//	
//	update();
//}

void QGLDistancePanel::closeEvent(QCloseEvent *event) {

	emit closeEvent(this);
	QWidget::closeEvent(event);
}

void QGLDistancePanel::showEvent(QShowEvent *event) {

	emit showEvent(this);
	QWidget::showEvent(event);
}