Hallo Gemeinde,
habe ein echt doofes Problem Text darzustellen (s. Markierung)
habe ein echt doofes Problem Text darzustellen (s. Markierung)
Code:
#ifdef __MAIN_RUN__
MyQVariant speichervar = 0.00;
MyQVariant strtest1 = QString();
#endif
speichervar = MyQVariant(210.250000 + 2.000000);
print_console(MyQVariant(speichervar)); // das geht noch
strtest1 = QString("das ist gross").toUpper();
print_console(strtest1); // <-- hier das nicht
speichervar = QString("Keine kleinSchrifT").toUpper();
print_console(MyQVariant(speichervar)); // <--- hier dito
void print_console(QString val)
{
//if (debug_console == 1)
{
#ifdef WIN32
DWORD i;
AllocConsole();
#endif
char buffer[2048];
sprintf(buffer,"%s\n",val.toStdString().c_str());
#ifdef WIN32
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE),buffer,strlen(buffer),&i,NULL);
#else
printf(buffer);
#endif
}
}
void print_console(double val)
{
///if (debug_console == 1)
{
#ifdef WIN32
DWORD i;
AllocConsole();
#endif
char buffer[2048];
sprintf(buffer,"%f\n",val);
#ifdef WIN32
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE),buffer,strlen(buffer),&i,NULL);
#else
printf(buffer);
#endif
}
}
void print_console(MyQVariant x)
{
//if (debug_console == 1)
{
if (x.value_type == MYQVAR_TYPE_DOUBLE( print_console(double (x.value_double)); else
if (x.value_type == MYQVAR_TYPE_STRING) print_console(QString(x.value_string));
}
}
#ifndef __MYQVARIANT_H__
#define __MYQVARIANT_H__
#include "all.h"
using namespace std;
using namespace boost;
class MyQVariant;
extern void print_console(double);
extern void print_console(QString);
extern void print_console(MyQVariant);
extern void print_console(MyQVariant*);
extern int my_strlen (MyQVariant);
extern QString my_date_now(void);
extern QString my_time_now(void);
extern void my_set_time (QString);
extern void msgbox(QString tstr, QString mstr);
extern void console_get_line(void);
#define MYQVAR_TYPE_DOUBLE 1
#define MYQVAR_TYPE_STRING 2
class MyQVariant: public QString
{
public:
MyQVariant();
MyQVariant(MyQVariant *);
MyQVariant(double);
MyQVariant(QString&);
MyQVariant(QString);
MyQVariant(int);
MyQVariant(const int&);
template<unsigned int N> MyQVariant(boost::multi_array<MyQVariant, N> & );
template<unsigned int N> MyQVariant(boost::multi_array<MyQVariant, N> &, boost::multi_array<MyQVariant, N> &);
MyQVariant& operator += (MyQVariant&);
MyQVariant& operator -= (MyQVariant&);
MyQVariant& operator *= (MyQVariant&);
MyQVariant& operator /= (MyQVariant&);
MyQVariant& operator * (MyQVariant&);
MyQVariant& operator += (double);
MyQVariant& operator -= (double);
MyQVariant& operator *= (double);
MyQVariant& operator /= (double);
MyQVariant& operator += (QString&);
MyQVariant& operator = (double);
MyQVariant& operator + (double);
MyQVariant& operator - (double);
MyQVariant& operator * (double);
MyQVariant& operator / (double);
MyQVariant& operator = (int);
MyQVariant& operator + (int);
MyQVariant& operator += (int);
MyQVariant& operator = (QString);
MyQVariant& operator + (QString);
operator int () {
this->value_type = MYQVAR_TYPE_DOUBLE;
return static_cast<int>(this->value_double);
}
operator double () {
this->value_type = MYQVAR_TYPE_DOUBLE;
return static_cast<int>(this->value_double);
}
MyQVariant& operator = (MyQVariant&);
bool operator == (double i) const { return ( this->value_double == i); }
bool operator != (double i) const { return ( this->value_double != i); }
public:
int value_type;
int last_type;
double value_double;
QString value_string;
};
class MyObjectTypes {
public:
MyObjectTypes() { }
int type;
double value;
QString str;
QWidget *widget, *form;
QString dbfview;
};
#ifdef __MAIN_RUN__
QVector<MyObjectTypes> f_types;
#else
extern QVector<MyObjectTypes> f_types;
#endif
#ifdef __MAIN_RUN__
template <typename Array>
void print(Array& A)
{
typename Array::const_iterator i;
QString s;
s = QString("[");
for (i = A.begin(); i != A.end(); ++i)
{
if (boost::next(i) != A.end())
{
s = s + static_cast<MyQVariant>(A).value_string; // leer
s = s + QString(",");
}
}
s = s + QString("]");
print_console(QString(s));
}
template<unsigned int N> MyQVariant::MyQVariant(boost::multi_array<MyQVariant, N> &A)
{
A[0][0].value_string = QString("paule");
}
template<unsigned int N> MyQVariant::MyQVariant(boost::multi_array<MyQVariant, N> &E, boost::multi_array<MyQVariant, N> &A)
{
std::vector<size_t> ex;
const size_t* shape = A.shape();
ex.assign(shape, shape + A.num_dimensions());
E.resize(ex);
E = A;
}
MyQVariant::MyQVariant()
{
this->value_type = MYQVAR_TYPE_STRING;
}
MyQVariant::MyQVariant(MyQVariant *c)
{
print_console(QString("ptr opj"));
this->value_double = double (c->value_double);
this->value_string = QString(c->value_string);
this->value_type = c->value_type;
}
MyQVariant::MyQVariant(double val)
{
value_type = MYQVAR_TYPE_DOUBLE;
value_double = val;
}
// <obj> = QString
MyQVariant::MyQVariant(QString& str)
{
this->value_type = MYQVAR_TYPE_STRING;
this->value_string = str;
}
MyQVariant::MyQVariant(QString str)
{
this->value_type = MYQVAR_TYPE_STRING;
this->value_string = str;
}
MyQVariant::MyQVariant(int val)
{
this->value_type = MYQVAR_TYPE_DOUBLE;
this->value_double = val;
}
MyQVariant& MyQVariant::operator * (MyQVariant& rhs)
{
print_console(QString("einfachmal"));
this->value_type = MYQVAR_TYPE_DOUBLE;
this->value_double =
this->value_double +
rhs. value_double ; return *this;
}
MyQVariant& MyQVariant::operator += (MyQVariant& rhs)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double +
rhs. value_double ; return *this;
}
MyQVariant& MyQVariant::operator += (QString& rhs)
{
print_console(QString("<--55-->"));
if (this->value_type == MYQVAR_TYPE_DOUBLE) {
this->value_double =
this->value_double + rhs.size() ;
this->value_type = MYQVAR_TYPE_DOUBLE; } else
if (this->value_type == MYQVAR_TYPE_STRING) {
this->value_string =
this->value_string + rhs;
this->value_type = MYQVAR_TYPE_STRING;
}
return *this;
}
MyQVariant& MyQVariant::operator -= (MyQVariant& rhs)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double -
rhs. value_double ; return *this;
}
MyQVariant& MyQVariant::operator *= (MyQVariant& rhs)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double *
rhs. value_double ; return *this;
}
MyQVariant& MyQVariant::operator /= (MyQVariant& rhs)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double /
rhs. value_double ; return *this;
}
MyQVariant& MyQVariant::operator += (double val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double + val; return *this;
}
MyQVariant& MyQVariant::operator -= (double val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double - val; return *this;
}
MyQVariant& MyQVariant::operator *= (double val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double * val; return *this;
}
MyQVariant& MyQVariant::operator /= (double val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double / val; return *this;
}
MyQVariant& MyQVariant::operator += (int val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double =
this->value_double + val; return *this;
}
// <objref> = 123;
MyQVariant& MyQVariant::operator = (int rhs)
{
this->last_type = MYQVAR_TYPE_DOUBLE;
this->value_type = MYQVAR_TYPE_STRING;
this->value_string = QString::number(rhs);
this->value_double = rhs;
return *this;
}
MyQVariant& MyQVariant::operator = (double rhs)
{
this->value_type = MYQVAR_TYPE_DOUBLE;
this->value_double = rhs;
return *this;
}
// <objref> = Qstring
MyQVariant& MyQVariant::operator = (QString rhs)
{
printf(": %s\n",rhs.toStdString().c_str());
MyQVariant *tmp = new MyQVariant(QString(rhs));
tmp->value_type = tmp->last_type = MYQVAR_TYPE_STRING;
tmp->value_string = rhs;
return *tmp;
}
MyQVariant& MyQVariant::operator + (int rhs)
{
this->last_type = MYQVAR_TYPE_DOUBLE;
this->value_type = MYQVAR_TYPE_STRING;
this->value_double += rhs;
QString num = QString::number(this->value_double);
int z = num.toInt();
num = QString::number(z);
this->value_string = num;
return *this;
}
MyQVariant& MyQVariant::MyQVariant::operator + (QString val)
{
print_console(QString("<--66-->"));
this->value_type = MYQVAR_TYPE_STRING;
this->value_string = this->value_string + val;
return *this;
}
MyQVariant& MyQVariant::MyQVariant::operator + (double val)
{
this->last_type = MYQVAR_TYPE_DOUBLE;
this->value_type = MYQVAR_TYPE_STRING;
this->value_double = this->value_double + val;
QString num = QString::number(this->value_double);
int z = num.toInt();
num = QString::number(z);
this->value_string = num;
return *this;
}
MyQVariant& MyQVariant::MyQVariant::operator - (double val)
{
this->value_double = this->value_double - val;
return *this;
}
MyQVariant& MyQVariant::MyQVariant::operator * (double val)
{
print_console(QString("mal"));
this->value_type = MYQVAR_TYPE_DOUBLE ;
this->value_double = this->value_double * val;
return *this;
}
MyQVariant& MyQVariant::MyQVariant::operator / (double val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double = this->value_double / val;
return *this;
}
/*
MyQVariant& MyQVariant::operator + (int val)
{
if (value_type == MYQVAR_TYPE_DOUBLE)
this->value_double = this->value_double + val; else
this->value_string = this->value_string + QString(val);
return *this;
}
*/
MyQVariant& MyQVariant::operator = (MyQVariant& rhs)
{
if (rhs.value_type == MYQVAR_TYPE_STRING)
rhs.value_string = this->value_string;
return *this;
}
QString operator + (double rhs, MyQVariant lhs)
{
char buffer[2048];
sprintf(buffer,"%s%f",lhs.value_string.toLatin1().data(),rhs);
printf("----> %s\n",buffer);
lhs.value_type = MYQVAR_TYPE_STRING;
lhs.value_string = QString(buffer);
return lhs.value_string;
}
const char* operator + (const char* rhs, MyQVariant lhs)
{
std::string res;
res = std::string(rhs) + std::string(lhs.value_string.toLatin1().data());
return res.c_str();
}
int operator - (int lhs, MyQVariant& rhs)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double -= lhs;
return rhs.value_double;
}
int operator + (int lhs, MyQVariant& rhs)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double += lhs;
return rhs.value_double;
}
int operator * (int lhs, MyQVariant& rhs)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double *= lhs;
return rhs.value_double;
}
int operator / (int lhs, MyQVariant& rhs)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double /= lhs;
return rhs.value_double;
}
// double = <objref> + <objref>
double operator + (MyQVariant lhs, MyQVariant& rhs)
{
if (rhs.last_type == MYQVAR_TYPE_DOUBLE)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double = lhs.value_double + rhs.value_double;
rhs.value_string = QString::number(rhs.value_double);
return rhs.value_double;
}
}
double operator - (double lhs, MyQVariant& rhs)
{
rhs.value_type = MYQVAR_TYPE_DOUBLE;
rhs.value_double -= lhs;
return rhs.value_double;
}
double operator + (double lhs, MyQVariant& rhs)
{
rhs.value_double += lhs;
return rhs.value_double;
}
double operator * (double lhs, MyQVariant& rhs)
{
print_console(QString("doublemmal"));
rhs.value_double *= lhs;
return rhs.value_double;
}
double operator / (double lhs, MyQVariant& rhs)
{
rhs.value_double /= lhs;
return rhs.value_double;
}
#endif
#endif