Import TinyXML and DataTree, OSX related UI tweaks

CMakeLists.txt

@@ -135,6 +135,7 @@ SET (cubicsdr_sources
 	src/util/Timer.cpp
 	src/util/MouseTracker.cpp
 	src/util/GLFont.cpp
+    src/util/DataTree.cpp
 	src/visual/PrimaryGLContext.cpp
 	src/visual/InteractiveCanvas.cpp
 	src/visual/MeterCanvas.cpp
@@ -151,6 +152,10 @@ SET (cubicsdr_sources
 	src/visual/WaterfallContext.cpp
 	external/rtaudio/RtAudio.cpp
 	external/lodepng/lodepng.cpp
+    external/tinyxml/tinyxml.cpp
+    external/tinyxml/tinystr.cpp
+    external/tinyxml/tinyxmlparser.cpp
+    external/tinyxml/tinyxmlerror.cpp
 )
 
 SET (cubicsdr_headers
@@ -171,6 +176,7 @@ SET (cubicsdr_headers
 	src/util/ThreadQueue.h
 	src/util/MouseTracker.h
 	src/util/GLFont.h
+    src/util/DataTree.h
 	src/visual/PrimaryGLContext.h
 	src/visual/InteractiveCanvas.h
 	src/visual/MeterCanvas.h
@@ -187,6 +193,8 @@ SET (cubicsdr_headers
 	src/visual/WaterfallContext.h
 	external/rtaudio/RtAudio.h
 	external/lodepng/lodepng.h
+    external/tinyxml/tinyxml.h
+    external/tinyxml/tinystr.h
 )
 
 include_directories ( 
@@ -198,6 +206,8 @@ include_directories (
 	${PROJECT_SOURCE_DIR}/src
 	${PROJECT_SOURCE_DIR}/external/rtaudio
 	${PROJECT_SOURCE_DIR}/external/lodepng 
+	${PROJECT_SOURCE_DIR}/external/fastlz 
+	${PROJECT_SOURCE_DIR}/external/tinyxml
 )
 
 ADD_DEFINITIONS(

external/tinyxml/tinystr.cpp

@@ -0,0 +1,116 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original file by Yves Berquin.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+/*
+ * THIS FILE WAS ALTERED BY Tyge L?vset, 7. April 2005.
+ */
+
+
+#ifndef TIXML_USE_STL
+
+#include "tinystr.h"
+
+// Error value for find primitive
+const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
+
+
+// Null rep.
+TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
+
+
+void TiXmlString::reserve (size_type cap)
+{
+	if (cap > capacity())
+	{
+		TiXmlString tmp;
+		tmp.init(length(), cap);
+		memcpy(tmp.start(), data(), length());
+		swap(tmp);
+	}
+}
+
+
+TiXmlString& TiXmlString::assign(const char* str, size_type len)
+{
+	size_type cap = capacity();
+	if (len > cap || cap > 3*(len + 8))
+	{
+		TiXmlString tmp;
+		tmp.init(len);
+		memcpy(tmp.start(), str, len);
+		swap(tmp);
+	}
+	else
+	{
+		memmove(start(), str, len);
+		set_size(len);
+	}
+	return *this;
+}
+
+
+TiXmlString& TiXmlString::append(const char* str, size_type len)
+{
+	size_type newsize = length() + len;
+	if (newsize > capacity())
+	{
+		reserve (newsize + capacity());
+	}
+	memmove(finish(), str, len);
+	set_size(newsize);
+	return *this;
+}
+
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	tmp.reserve(a.length() + b.length());
+	tmp += a;
+	tmp += b;
+	return tmp;
+}
+
+TiXmlString operator + (const TiXmlString & a, const char* b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
+	tmp.reserve(a.length() + b_len);
+	tmp += a;
+	tmp.append(b, b_len);
+	return tmp;
+}
+
+TiXmlString operator + (const char* a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
+	tmp.reserve(a_len + b.length());
+	tmp.append(a, a_len);
+	tmp += b;
+	return tmp;
+}
+
+
+#endif	// TIXML_USE_STL

external/tinyxml/tinystr.h

@@ -0,0 +1,319 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original file by Yves Berquin.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+/*
+ * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
+ *
+ * - completely rewritten. compact, clean, and fast implementation.
+ * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
+ * - fixed reserve() to work as per specification.
+ * - fixed buggy compares operator==(), operator<(), and operator>()
+ * - fixed operator+=() to take a const ref argument, following spec.
+ * - added "copy" constructor with length, and most compare operators.
+ * - added swap(), clear(), size(), capacity(), operator+().
+ */
+
+#ifndef TIXML_USE_STL
+
+#ifndef TIXML_STRING_INCLUDED
+#define TIXML_STRING_INCLUDED
+
+#include <assert.h>
+#include <string.h>
+
+/*	The support for explicit isn't that universal, and it isn't really
+	required - it is used to check that the TiXmlString class isn't incorrectly
+	used. Be nice to old compilers and macro it here:
+*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+	// Microsoft visual studio, version 6 and higher.
+	#define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+	// GCC version 3 and higher.s
+	#define TIXML_EXPLICIT explicit
+#else
+	#define TIXML_EXPLICIT
+#endif
+
+
+/*
+   TiXmlString is an emulation of a subset of the std::string template.
+   Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
+   Only the member functions relevant to the TinyXML project have been implemented.
+   The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
+   a string and there's no more room, we allocate a buffer twice as big as we need.
+*/
+class TiXmlString
+{
+  public :
+	// The size type used
+  	typedef size_t size_type;
+
+	// Error value for find primitive
+	static const size_type npos; // = -1;
+
+
+	// TiXmlString empty constructor
+	TiXmlString () : rep_(&nullrep_)
+	{
+	}
+
+	// TiXmlString copy constructor
+	TiXmlString ( const TiXmlString & copy) : rep_(0)
+	{
+		init(copy.length());
+		memcpy(start(), copy.data(), length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
+	{
+		init( static_cast<size_type>( strlen(copy) ));
+		memcpy(start(), copy, length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
+	{
+		init(len);
+		memcpy(start(), str, len);
+	}
+
+	// TiXmlString destructor
+	~TiXmlString ()
+	{
+		quit();
+	}
+
+	// = operator
+	TiXmlString& operator = (const char * copy)
+	{
+		return assign( copy, (size_type)strlen(copy));
+	}
+
+	// = operator
+	TiXmlString& operator = (const TiXmlString & copy)
+	{
+		return assign(copy.start(), copy.length());
+	}
+
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const char * suffix)
+	{
+		return append(suffix, static_cast<size_type>( strlen(suffix) ));
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (char single)
+	{
+		return append(&single, 1);
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const TiXmlString & suffix)
+	{
+		return append(suffix.data(), suffix.length());
+	}
+
+
+	// Convert a TiXmlString into a null-terminated char *
+	const char * c_str () const { return rep_->str; }
+
+	// Convert a TiXmlString into a char * (need not be null terminated).
+	const char * data () const { return rep_->str; }
+
+	// Return the length of a TiXmlString
+	size_type length () const { return rep_->size; }
+
+	// Alias for length()
+	size_type size () const { return rep_->size; }
+
+	// Checks if a TiXmlString is empty
+	bool empty () const { return rep_->size == 0; }
+
+	// Return capacity of string
+	size_type capacity () const { return rep_->capacity; }
+
+
+	// single char extraction
+	const char& at (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// [] operator
+	char& operator [] (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// find a char in a string. Return TiXmlString::npos if not found
+	size_type find (char lookup) const
+	{
+		return find(lookup, 0);
+	}
+
+	// find a char in a string from an offset. Return TiXmlString::npos if not found
+	size_type find (char tofind, size_type offset) const
+	{
+		if (offset >= length()) return npos;
+
+		for (const char* p = c_str() + offset; *p != '\0'; ++p)
+		{
+		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
+		}
+		return npos;
+	}
+
+	void clear ()
+	{
+		//Lee:
+		//The original was just too strange, though correct:
+		//	TiXmlString().swap(*this);
+		//Instead use the quit & re-init:
+		quit();
+		init(0,0);
+	}
+
+	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
+		function DOES NOT clear the content of the TiXmlString if any exists.
+	*/
+	void reserve (size_type cap);
+
+	TiXmlString& assign (const char* str, size_type len);
+
+	TiXmlString& append (const char* str, size_type len);
+
+	void swap (TiXmlString& other)
+	{
+		Rep* r = rep_;
+		rep_ = other.rep_;
+		other.rep_ = r;
+	}
+
+  private:
+
+	void init(size_type sz) { init(sz, sz); }
+	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
+	char* start() const { return rep_->str; }
+	char* finish() const { return rep_->str + rep_->size; }
+
+	struct Rep
+	{
+		size_type size, capacity;
+		char str[1];
+	};
+
+	void init(size_type sz, size_type cap)
+	{
+		if (cap)
+		{
+			// Lee: the original form:
+			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
+			// doesn't work in some cases of new being overloaded. Switching
+			// to the normal allocation, although use an 'int' for systems
+			// that are overly picky about structure alignment.
+			const size_type bytesNeeded = sizeof(Rep) + cap;
+			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
+			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
+
+			rep_->str[ rep_->size = sz ] = '\0';
+			rep_->capacity = cap;
+		}
+		else
+		{
+			rep_ = &nullrep_;
+		}
+	}
+
+	void quit()
+	{
+		if (rep_ != &nullrep_)
+		{
+			// The rep_ is really an array of ints. (see the allocator, above).
+			// Cast it back before delete, so the compiler won't incorrectly call destructors.
+			delete [] ( reinterpret_cast<int*>( rep_ ) );
+		}
+	}
+
+	Rep * rep_;
+	static Rep nullrep_;
+
+} ;
+
+
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+{
+	return    ( a.length() == b.length() )				// optimization on some platforms
+	       && ( strcmp(a.c_str(), b.c_str()) == 0 );	// actual compare
+}
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+{
+	return strcmp(a.c_str(), b.c_str()) < 0;
+}
+
+inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
+inline bool operator >  (const TiXmlString & a, const TiXmlString & b) { return b < a; }
+inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
+inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
+
+inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
+inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
+inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
+inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
+TiXmlString operator + (const TiXmlString & a, const char* b);
+TiXmlString operator + (const char* a, const TiXmlString & b);
+
+
+/*
+   TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
+   Only the operators that we need for TinyXML have been developped.
+*/
+class TiXmlOutStream : public TiXmlString
+{
+public :
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const TiXmlString & in)
+	{
+		*this += in;
+		return *this;
+	}
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const char * in)
+	{
+		*this += in;
+		return *this;
+	}
+
+} ;
+
+#endif	// TIXML_STRING_INCLUDED
+#endif	// TIXML_USE_STL

external/tinyxml/tinyxmlerror.cpp

@@ -0,0 +1,53 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied 
+warranty. In no event will the authors be held liable for any 
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any 
+purpose, including commercial applications, and to alter it and 
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#include "tinyxml.h"
+
+// The goal of the seperate error file is to make the first
+// step towards localization. tinyxml (currently) only supports
+// english error messages, but the could now be translated.
+//
+// It also cleans up the code a bit.
+//
+
+const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
+{
+	"No error",
+	"Error",
+	"Failed to open file",
+	"Memory allocation failed.",
+	"Error parsing Element.",
+	"Failed to read Element name",
+	"Error reading Element value.",
+	"Error reading Attributes.",
+	"Error: empty tag.",
+	"Error reading end tag.",
+	"Error parsing Unknown.",
+	"Error parsing Comment.",
+	"Error parsing Declaration.",
+	"Error document empty.",
+	"Error null (0) or unexpected EOF found in input stream.",
+	"Error parsing CDATA.",
+	"Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
+};

src/AppFrame.cpp

@@ -46,6 +46,7 @@ AppFrame::AppFrame() :
     demodModeSelector->addChoice(DEMOD_TYPE_AM,"AM");
     demodModeSelector->addChoice(DEMOD_TYPE_LSB,"LSB");
     demodModeSelector->addChoice(DEMOD_TYPE_USB,"USB");
+    demodModeSelector->addChoice(DEMOD_TYPE_DSB,"DSB");
     demodTray->Add(demodModeSelector, 2, wxEXPAND | wxALL, 0);
 
 //    demodTray->AddSpacer(2);

src/demod/DemodDefs.h

@@ -12,6 +12,7 @@
 #define DEMOD_TYPE_AM 2
 #define DEMOD_TYPE_LSB 3
 #define DEMOD_TYPE_USB 4
+#define DEMOD_TYPE_DSB 5
 
 
 class DemodulatorThread;

src/demod/DemodulatorThread.cpp

@@ -16,6 +16,7 @@ DemodulatorThread::DemodulatorThread(DemodulatorThreadPostInputQueue* iqInputQue
     demodFM = freqdem_create(0.5);
     demodAM_USB = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_LSB, 1);
     demodAM_LSB = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_USB, 1);
+    demodAM_DSB = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_DSB, 1);
     demodAM_DSB_CSP = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_DSB, 0);
     demodAM = demodAM_DSB_CSP;
 
@@ -174,6 +175,7 @@ void DemodulatorThread::threadMain() {
                 }
                 break;
             case DEMOD_TYPE_AM:
+            case DEMOD_TYPE_DSB:
                 break;
             }
 
@@ -357,6 +359,9 @@ void DemodulatorThread::threadMain() {
                 case DEMOD_TYPE_USB:
                     demodAM = demodAM_LSB;
                     break;
+                case DEMOD_TYPE_DSB:
+                    demodAM = demodAM_DSB;
+                    break;
                 case DEMOD_TYPE_AM:
                     demodAM = demodAM_DSB_CSP;
                     break;

src/demod/DemodulatorThread.h

@@ -62,6 +62,7 @@ protected:
     freqdem demodFM;
     ampmodem demodAM;
     ampmodem demodAM_DSB_CSP;
+    ampmodem demodAM_DSB;
     ampmodem demodAM_LSB;
     ampmodem demodAM_USB;
 

src/util/DataTree.h

@@ -0,0 +1,335 @@
+#pragma once
+/*
+ * DataElement/DataNode/DataTree -- structured serialization/deserialization system
+ * designed for the CoolMule project :)
+ *
+ Copyright (C) 2003 by Charles J. Cliffe
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+#define USE_FASTLZ 0
+
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+#include <sstream>
+#include <stack>
+#include <iostream>
+#include "tinyxml.h"
+
+#if USE_FASTLZ
+#include "fastlz.h"
+#endif
+
+using namespace std;
+
+
+/* type defines */
+#define DATA_NULL				0
+#define DATA_CHAR               1
+#define DATA_UCHAR              2
+#define DATA_INT				3
+#define DATA_UINT               4
+#define DATA_LONG				5
+#define DATA_ULONG              6
+#define DATA_LONGLONG           7
+#define DATA_ULONGLONG          8
+#define DATA_FLOAT				9
+#define DATA_DOUBLE				10
+#define DATA_LONGDOUBLE         11
+#define DATA_STRING				12
+#define DATA_STR_VECTOR		    13
+#define DATA_CHAR_VECTOR        14
+#define DATA_UCHAR_VECTOR       15
+#define DATA_INT_VECTOR		    16
+#define DATA_UINT_VECTOR        17
+#define DATA_LONG_VECTOR		18
+#define DATA_ULONG_VECTOR       19
+#define DATA_LONGLONG_VECTOR    20
+#define DATA_ULONGLONG_VECTOR   21
+#define DATA_FLOAT_VECTOR		22
+#define DATA_DOUBLE_VECTOR		23
+#define DATA_LONGDOUBLE_VECTOR  24
+#define DATA_VOID               25
+
+
+/* map comparison function */
+struct string_less : public std::binary_function<std::string,std::string,bool>
+{
+ bool operator()(const std::string& a,const std::string& b) const
+ {
+  return a.compare(b) < 0;
+ }
+};
+
+/* int comparison function */
+struct int_less : public std::binary_function<int,int,bool>
+{
+ bool operator()(int a,int b) const
+ {
+        return a < b;
+ }
+};
+
+
+/* Data Exceptions */
+class DataException
+{
+private:
+    string reason;
+    
+public:
+    DataException(const char *why) : reason(why) {}
+    string what() { return reason; } 
+    operator string() { return reason; }
+};
+
+
+class DataTypeMismatchException : public DataException
+{
+public:
+    DataTypeMismatchException(const char *why) : DataException(why) { }
+};
+
+
+class DataInvalidChildException : public DataException
+{
+public:
+    DataInvalidChildException(const char *why) : DataException(why) { }
+};
+
+
+class DataElement
+{
+private:
+    unsigned char data_type;
+    unsigned int data_size;
+    
+    char *data_val;
+    
+    void data_init(long data_size_in);
+    
+public:
+    DataElement();
+    ~DataElement();
+    
+    int getDataType();
+    long getDataSize();
+    
+    /* set overloads */		
+    //		void set(const bool &bool_in);
+    void set(const char &char_in);
+    void set(const unsigned char &uchar_in);
+    void set(const int &int_in);
+    void set(const unsigned int &uint_in);
+    void set(const long &long_in);
+    void set(const unsigned long &ulong_in);
+    void set(const long long &llong_in);
+    void set(const float &float_in);
+    void set(const double &double_in);
+    void set(const long double &ldouble_in);
+    
+    void set(const char *data_in, long size_in); /* voids, file chunks anyone? */
+    void set(const char *data_in);	/* strings, stops at NULL, returns as string */
+    
+    void set(const string &str_in);
+    
+    void set(vector<string> &strvect_in);
+    void set(std::set<string> &strset_in);
+    void set(vector<char> &charvect_in);
+    void set(vector<unsigned char> &ucharvect_in);
+    void set(vector<int> &intvect_in);
+    void set(vector<unsigned int> &uintvect_in);
+    void set(vector<long> &longvect_in);
+    void set(vector<unsigned long> &ulongvect_in);
+    void set(vector<long long> &llongvect_in);
+    void set(vector<float> &floatvect_in);
+    void set(vector<double> &doublevect_in);
+    void set(vector<long double> &ldoublevect_in);
+    
+    
+    /* get overloads */
+    void get(char &char_in) throw (DataTypeMismatchException);
+    void get(unsigned char &uchar_in) throw (DataTypeMismatchException);
+    void get(int &int_in) throw (DataTypeMismatchException);
+    void get(unsigned int &uint_in) throw (DataTypeMismatchException);
+    void get(long &long_in) throw (DataTypeMismatchException);
+    void get(unsigned long &ulong_in) throw (DataTypeMismatchException);
+    void get(long long &long_in) throw (DataTypeMismatchException);
+    void get(float &float_in) throw (DataTypeMismatchException);
+    void get(double &double_in) throw (DataTypeMismatchException);
+    void get(long double &ldouble_in) throw (DataTypeMismatchException);
+    
+    void get(char **data_in) throw (DataTypeMismatchException); /* getting a void or string */
+    void get(string &str_in) throw (DataTypeMismatchException); 
+    void get(std::set<string> &strset_in) throw (DataTypeMismatchException);
+    
+    void get(vector<string> &strvect_in) throw (DataTypeMismatchException);
+    void get(vector<char> &charvect_in) throw (DataTypeMismatchException);
+    void get(vector<unsigned char> &ucharvect_in) throw (DataTypeMismatchException);
+    void get(vector<int> &intvect_in) throw (DataTypeMismatchException);
+    void get(vector<unsigned int> &uintvect_in) throw (DataTypeMismatchException);
+    void get(vector<long> &longvect_in) throw (DataTypeMismatchException);
+    void get(vector<unsigned long> &ulongvect_in) throw (DataTypeMismatchException);
+    void get(vector<long long> &llongvect_in) throw (DataTypeMismatchException);
+    void get(vector<float> &floatvect_in) throw (DataTypeMismatchException);
+    void get(vector<double> &doublevect_in) throw (DataTypeMismatchException);
+    void get(vector<long double> &ldoublevect_in) throw (DataTypeMismatchException);
+    
+    
+    /* special get functions, saves creating unnecessary vars */
+    int getChar() throw (DataTypeMismatchException) { char i_get; get(i_get); return i_get; };
+    unsigned int getUChar() throw (DataTypeMismatchException) { unsigned char i_get; get(i_get); return i_get; };
+    int getInt() throw (DataTypeMismatchException) { int i_get; get(i_get); return i_get; };
+    unsigned int getUInt() throw (DataTypeMismatchException) { unsigned int i_get; get(i_get); return i_get; };
+    long getLong() throw (DataTypeMismatchException)  { long l_get; get(l_get); return l_get; };
+    unsigned long getULong() throw (DataTypeMismatchException)  { unsigned long l_get; get(l_get); return l_get; };
+    long getLongLong() throw (DataTypeMismatchException)  { long long l_get; get(l_get); return l_get; };
+    float getFloat() throw (DataTypeMismatchException)  { float f_get; get(f_get); return f_get; };
+    double getDouble() throw (DataTypeMismatchException)  { double d_get; get(d_get); return d_get; };
+    long double getLongDouble() throw (DataTypeMismatchException)  { long double d_get; get(d_get); return d_get; };
+    
+    
+    /* serialize functions */
+    long getSerializedSize();
+    long getSerialized(char **ser_str);
+    
+    void setSerialized(char *ser_str);
+};
+
+
+class DataNode
+{
+private:
+    DataNode *parentNode;
+    vector<DataNode *> children;
+    map<string, vector<DataNode *>, string_less> childmap;
+    map<string, unsigned int, string_less> childmap_ptr;
+    
+    string node_name;
+    DataElement data_elem;
+    unsigned int ptr;
+    
+    
+public:
+    DataNode();
+    DataNode(const char *name_in);
+    
+    ~DataNode();		
+    
+    void setName(const char *name_in);
+    string &getName() { return node_name; }
+
+    DataNode *getParentNode() { return parentNode; };
+    void setParentNode(DataNode &parentNode_in) { parentNode = &parentNode_in; };
+
+    int numChildren();	/* Number of children */
+    int numChildren(const char *name_in); /* Number of children named 'name_in' */
+    
+    DataElement &element(); /* DataElement at this node */
+    
+    DataNode &newChild(const char *name_in);
+    DataNode &child(const char *name_in, int index = 0) throw (DataInvalidChildException);
+    DataNode &child(int index) throw (DataInvalidChildException);
+    
+    
+    bool hasAnother(const char *name_in);	/* useful for while() loops in conjunction with getNext() */
+    bool hasAnother();
+    DataNode &getNext(const char *name_in) throw (DataInvalidChildException); /* get next of specified name */
+    DataNode &getNext() throw (DataInvalidChildException);	/* get next child */
+    void rewind(const char *name_in);	/* rewind specific */
+    void rewind();	/* rewind generic */
+        
+    void findAll(const char *name_in, vector<DataNode *> &node_list_out);
+    
+    operator string () { string s; element().get(s); return s; }
+    operator int () { int v; element().get(v); return v; }
+    operator long () { long v; element().get(v); return v; }
+    operator float () { float v; element().get(v); return v; }
+    operator double () { double v; element().get(v); return v; }
+
+    operator vector<int> () { vector<int> v; element().get(v);  return v; }
+    operator vector<long> () { vector<long> v; element().get(v);  return v; }
+    operator vector<float> () { vector<float> v; element().get(v);  return v; }
+    operator vector<double> () { vector<double> v; element().get(v);  return v; }
+    
+    const string &operator= (const string &s) { element().set(s); return s; }
+
+    int operator= (int i) { element().set(i); return i; }
+    long operator= (long i) { element().set(i); return i; }
+    float operator= (float i) { element().set(i); return i; }
+    double operator= (double i) { element().set(i); return i; }
+
+    
+    vector<int> &operator= (vector<int> &v) { element().set(v); return v; }
+    vector<long> &operator= (vector<long> &v) { element().set(v); return v; }
+    vector<float> &operator= (vector<float> &v) { element().set(v); return v; }
+    vector<double> &operator= (vector<double> &v) { element().set(v); return v; }
+
+    DataNode &operator[] (const char *name_in) { return getNext(name_in); }
+    DataNode &operator[] (int idx) { return child(idx); }
+
+    bool operator() (const char *name_in) { return hasAnother(name_in); }
+    bool operator() () { return hasAnother(); }
+
+    DataNode &operator ^(const char *name_in) { return newChild(name_in); }
+
+};
+
+
+typedef vector<DataNode *> DataNodeList;
+
+enum DT_FloatingPointPolicy {
+    USE_FLOAT,
+    USE_DOUBLE
+};
+
+class DataTree
+{
+private:
+    DataNode dn_root;
+    
+public:
+    DataTree(const char *name_in);
+    DataTree();
+    ~DataTree();
+    
+    DataNode &rootNode();
+    
+    void nodeToXML(DataNode *elem, TiXmlElement *elxml);
+    void setFromXML(DataNode *elem, TiXmlNode *elxml, bool root_node=true, DT_FloatingPointPolicy fpp=USE_FLOAT);
+    void decodeXMLText(DataNode *elem, const char *in_text, DT_FloatingPointPolicy fpp);
+    
+    void printXML();	/* print datatree as XML */
+    long getSerializedSize(DataElement &de_node_names, bool debug=false);	/* get serialized size + return node names header */
+    long getSerialized(char **ser_str, bool debug=false);	
+    void setSerialized(char *ser_str, bool debug=false);
+    
+    bool LoadFromFileXML(const std::string& filename, DT_FloatingPointPolicy fpp=USE_FLOAT);
+    bool SaveToFileXML(const std::string& filename);
+    
+//    bool SaveToFile(const std::string& filename);
+//    bool LoadFromFile(const std::string& filename);
+
+    bool SaveToFile(const std::string& filename, bool compress = true, int compress_level = 2);
+    bool LoadFromFile(const std::string& filename);
+};
+

src/visual/TuningCanvas.cpp

@@ -51,40 +51,46 @@ void TuningCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
         glContext->DrawDemodFreqBw(0, 0, wxGetApp().getFrequency());
     }
 
+    if (mouseTracker.mouseDown()) {
+        glContext->Draw(0.2, 0.2, 0.9, 0.6, mouseTracker.getOriginMouseX(), mouseTracker.getMouseX());
+    }
+
     glContext->DrawEnd();
 
     SwapBuffers();
 }
 
 void TuningCanvas::OnIdle(wxIdleEvent &event) {
+    if (mouseTracker.mouseDown()) {
+        DemodulatorInstance *activeDemod = wxGetApp().getDemodMgr().getLastActiveDemodulator();
+
+        dragAccum += mouseTracker.getMouseX() - mouseTracker.getOriginMouseX();
+
+        if (uxDown > 0.275) {
+            wxGetApp().setFrequency(wxGetApp().getFrequency() + (int) (mouseTracker.getOriginDeltaMouseX() * SRATE * 15.0));
+        }
+
+        if (abs(dragAccum * 10.0) >= 1) {
+            if (uxDown < -0.275 && activeDemod != NULL) {
+                activeDemod->setFrequency(activeDemod->getFrequency() + (int) (dragAccum * 10.0));
+            } else if (activeDemod != NULL) {
+                activeDemod->setBandwidth(activeDemod->getBandwidth() + (int) (dragAccum * 10.0));
+            }
+
+            while (dragAccum * 10.0 >= 1.0) {
+                dragAccum -= 1.0 / 10.0;
+            }
+            while (dragAccum * -10.0 <= -1.0) {
+                dragAccum += 1.0 / 10.0;
+            }
+        }
+    }
+
     Refresh(false);
 }
 
 void TuningCanvas::OnMouseMoved(wxMouseEvent& event) {
     InteractiveCanvas::OnMouseMoved(event);
-
-    if (mouseTracker.mouseDown()) {
-        DemodulatorInstance *activeDemod = wxGetApp().getDemodMgr().getLastActiveDemodulator();
-
-        float uxPos = 2.0 * (mouseTracker.getMouseX() - 0.5);
-
-        dragAccum += mouseTracker.getDeltaMouseX();
-
-        if (uxPos < -0.275 && activeDemod != NULL) {
-            if (abs(dragAccum * 100.0) >= 1) {
-                activeDemod->setFrequency(activeDemod->getFrequency() + (int) (dragAccum * 100.0));
-                dragAccum = 0;
-            }
-        } else if (uxPos > 0.275) {
-            wxGetApp().setFrequency(wxGetApp().getFrequency() + (int) (mouseTracker.getDeltaMouseX() * SRATE * 100.0));
-            dragAccum = 0;
-        } else if (activeDemod != NULL) {
-            if (abs(dragAccum * 100.0) >= 1) {
-                activeDemod->setBandwidth(activeDemod->getBandwidth() + (int) (dragAccum * 100.0));
-                dragAccum = 0;
-            }
-        }
-    }
 }
 
 void TuningCanvas::OnMouseDown(wxMouseEvent& event) {
@@ -92,6 +98,8 @@ void TuningCanvas::OnMouseDown(wxMouseEvent& event) {
     mouseTracker.setHorizDragLock(true);
     mouseTracker.setVertDragLock(true);
 
+    uxDown = 2.0 * (mouseTracker.getMouseX() - 0.5);
+
     dragAccum = 0;
     SetCursor (wxCURSOR_IBEAM);
 }

src/visual/TuningCanvas.h

@@ -35,6 +35,7 @@ private:
 
     std::string helpTip;
     float dragAccum;
+    float uxDown;
     //
 wxDECLARE_EVENT_TABLE();
 };

src/visual/TuningContext.cpp

@@ -34,15 +34,15 @@ void TuningContext::DrawBegin() {
     glDisable(GL_TEXTURE_2D);
 }
 
-void TuningContext::Draw(float r, float g, float b, float a, float level) {
+void TuningContext::Draw(float r, float g, float b, float a, float p1, float p2) {
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE);
     glColor4f(r, g, b, a);
     glBegin(GL_QUADS);
-    glVertex2f(1.0, -1.0 + 2.0 * level);
+    glVertex2f(-1.0+p2*2.0, 1.0);
-    glVertex2f(-1.0, -1.0 + 2.0 * level);
+    glVertex2f(-1.0+p1*2.0, 1.0);
-    glVertex2f(-1.0, -1.0);
+    glVertex2f(-1.0+p1*2.0, -1.0);
-    glVertex2f(1.0, -1.0);
+    glVertex2f(-1.0+p2*2.0, -1.0);
     glEnd();
     glDisable(GL_BLEND);
 }
@@ -69,6 +69,8 @@ void TuningContext::DrawDemodFreqBw(long long freq, unsigned int bw, long long c
         fontHeight = 12;
     }
 
+    glColor3f(0.85, 0.85, 0.85);
+
     getFont(fontSize).drawString("Freq: ", -0.75, 0, fontHeight, GLFont::GLFONT_ALIGN_RIGHT, GLFont::GLFONT_ALIGN_CENTER);
     if (bw) {
         freqStr.str("");
@@ -78,11 +80,6 @@ void TuningContext::DrawDemodFreqBw(long long freq, unsigned int bw, long long c
     }
     getFont(fontSize).drawString(freqStr.str(), -0.75, 0, fontHeight, GLFont::GLFONT_ALIGN_LEFT, GLFont::GLFONT_ALIGN_CENTER);
 
-    glColor3f(0.65, 0.65, 0.65);
-    glBegin(GL_LINES);
-    glVertex2f(-0.275, -1.0);
-    glVertex2f(-0.275, 1.0);
-    glEnd();
 
     getFont(fontSize).drawString("BW: ", -0.10, 0, fontHeight, GLFont::GLFONT_ALIGN_RIGHT, GLFont::GLFONT_ALIGN_CENTER);
     if (bw) {
@@ -93,11 +90,6 @@ void TuningContext::DrawDemodFreqBw(long long freq, unsigned int bw, long long c
     }
     getFont(fontSize).drawString(freqStr.str(), -0.10, 0, fontHeight, GLFont::GLFONT_ALIGN_LEFT, GLFont::GLFONT_ALIGN_CENTER);
 
-    glColor3f(0.65, 0.65, 0.65);
-    glBegin(GL_LINES);
-    glVertex2f(0.275, -1.0);
-    glVertex2f(0.275, 1.0);
-    glEnd();
 
     getFont(fontSize).drawString("CTR: ", 0.50, 0, fontHeight, GLFont::GLFONT_ALIGN_RIGHT, GLFont::GLFONT_ALIGN_CENTER);
     if (center) {
@@ -107,5 +99,15 @@ void TuningContext::DrawDemodFreqBw(long long freq, unsigned int bw, long long c
         freqStr.str("---");
     }
     getFont(fontSize).drawString(freqStr.str(), 0.50, 0, fontHeight, GLFont::GLFONT_ALIGN_LEFT, GLFont::GLFONT_ALIGN_CENTER);
+
+
+    glColor3f(0.65, 0.65, 0.65);
+    glBegin(GL_LINES);
+    glVertex2f(-0.275, -1.0);
+    glVertex2f(-0.275, 1.0);
+    glVertex2f(0.275, -1.0);
+    glVertex2f(0.275, 1.0);
+    glEnd();
+
 }
 

src/visual/TuningContext.h

@@ -12,7 +12,7 @@ public:
     TuningContext(TuningCanvas *canvas, wxGLContext *sharedContext);
 
     void DrawBegin();
-    void Draw(float r, float g, float b, float a, float level);
+    void Draw(float r, float g, float b, float a, float p1, float p2);
     void DrawDemodFreqBw(long long freq, unsigned int bw, long long center);
     void DrawEnd();
 

src/visual/WaterfallCanvas.cpp

@@ -30,6 +30,7 @@ EVT_RIGHT_DOWN(WaterfallCanvas::OnMouseRightDown)
 EVT_RIGHT_UP(WaterfallCanvas::OnMouseRightReleased)
 EVT_LEAVE_WINDOW(WaterfallCanvas::OnMouseLeftWindow)
 EVT_ENTER_WINDOW(WaterfallCanvas::OnMouseEnterWindow)
+EVT_MOUSEWHEEL(WaterfallCanvas::OnMouseWheelMoved)
 wxEND_EVENT_TABLE()
 
 WaterfallCanvas::WaterfallCanvas(wxWindow *parent, int *attribList) :
@@ -302,6 +303,9 @@ void WaterfallCanvas::setData(DemodulatorThreadIQData *input) {
     if (mouseZoom != 1) {
         currentZoom = mouseZoom;
         mouseZoom = mouseZoom + (1.0 - mouseZoom) * 0.2;
+        if (fabs(mouseZoom-1.0)<0.01) {
+            mouseZoom = 1;
+        }
     }
 
     long long bw;
@@ -674,6 +678,9 @@ void WaterfallCanvas::OnMouseDown(wxMouseEvent& event) {
 
 void WaterfallCanvas::OnMouseWheelMoved(wxMouseEvent& event) {
     InteractiveCanvas::OnMouseWheelMoved(event);
+    float movement = (float)event.GetWheelRotation() / (float)event.GetLinesPerAction();
+
+    mouseZoom = 1.0f - movement/100.0f;
 }
 
 void WaterfallCanvas::OnMouseReleased(wxMouseEvent& event) {