You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
311 lines
9.3 KiB
311 lines
9.3 KiB
/***************************************************************************
|
|
* Copyright (C) 2005 by Niklas Knutsson *
|
|
* nq@altern.org *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* 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 General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
|
|
#include "qalculate_tde_utils.h"
|
|
#include <vector>
|
|
#include <string>
|
|
#include <list>
|
|
#include <tqwidget.h>
|
|
#include <tqlabel.h>
|
|
#include <tqlineedit.h>
|
|
#include <tqstring.h>
|
|
#include <tqfont.h>
|
|
#include <tqfontmetrics.h>
|
|
#include "kqalculate.h"
|
|
|
|
tree_struct function_cats, unit_cats, variable_cats;
|
|
std::vector<void*> ia_units, ia_variables, ia_functions;
|
|
std::vector<MathFunction*> recent_functions;
|
|
std::vector<Variable*> recent_variables;
|
|
std::vector<Unit*> recent_units;
|
|
extern PrintOptions printops;
|
|
extern KnownVariable *vans[5];
|
|
extern TQWidget *topWidget;
|
|
extern KQalculate *mainWin;
|
|
|
|
void insert_text_in_expression(const TQString &str) {
|
|
mainWin->insert_text(str);
|
|
}
|
|
|
|
bool is_answer_variable(Variable *v) {
|
|
return v == vans[0] || v == vans[1] || v == vans[2] || v == vans[3] || v == vans[4];
|
|
}
|
|
|
|
TQString get_value_string(const MathStructure &mstruct_, bool rlabel, Prefix *prefix) {
|
|
printops.allow_non_usable = rlabel;
|
|
printops.prefix = prefix;
|
|
TQString str = CALCULATOR->printMathStructureTimeOut(mstruct_, 100, printops).c_str();
|
|
printops.allow_non_usable = false;
|
|
printops.prefix = NULL;
|
|
return str;
|
|
}
|
|
|
|
void set_name_label_and_entry(ExpressionItem *item, TQLineEdit *entry, TQLabel *label) {
|
|
const ExpressionName *ename = &item->getName(1);
|
|
entry->setText(ename->name.c_str());
|
|
if(item->countNames() > 1) {
|
|
TQString str = "+ ";
|
|
for(size_t i = 2; i <= item->countNames(); i++) {
|
|
if(i > 2) str += ", ";
|
|
str += item->getName(i).name.c_str();
|
|
}
|
|
label->setText(str);
|
|
}
|
|
}
|
|
|
|
bool can_display_unicode_string_function(const char *str, void *arg) {
|
|
if(!arg) arg = (void*) topWidget;
|
|
TQFontMetrics fm(((TQWidget*) arg)->fontMetrics());
|
|
TQString qstr(str);
|
|
const TQChar *qchars = qstr.unicode();
|
|
for(uint i = 0; i < qstr.length(); i++) {
|
|
if(!fm.inFont(qchars[i])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void generate_units_tree_struct() {
|
|
size_t cat_i, cat_i_prev;
|
|
bool b;
|
|
std::string str, cat, cat_sub;
|
|
Unit *u = NULL;
|
|
unit_cats.items.clear();
|
|
unit_cats.objects.clear();
|
|
unit_cats.parent = NULL;
|
|
ia_units.clear();
|
|
std::list<tree_struct>::iterator it;
|
|
for(size_t i = 0; i < CALCULATOR->units.size(); i++) {
|
|
if(!CALCULATOR->units[i]->isActive()) {
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < ia_units.size(); i3++) {
|
|
u = (Unit*) ia_units[i3];
|
|
if(CALCULATOR->units[i]->title() < u->title()) {
|
|
b = true;
|
|
ia_units.insert(ia_units.begin() + i3, (void*) CALCULATOR->units[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) ia_units.push_back((void*) CALCULATOR->units[i]);
|
|
} else {
|
|
tree_struct *item = &unit_cats;
|
|
if(!CALCULATOR->units[i]->category().empty()) {
|
|
cat = CALCULATOR->units[i]->category();
|
|
cat_i = cat.find("/"); cat_i_prev = 0;
|
|
b = false;
|
|
while(true) {
|
|
if(cat_i == std::string::npos) {
|
|
cat_sub = cat.substr(cat_i_prev, cat.length() - cat_i_prev);
|
|
} else {
|
|
cat_sub = cat.substr(cat_i_prev, cat_i - cat_i_prev);
|
|
}
|
|
b = false;
|
|
for(it = item->items.begin(); it != item->items.end(); ++it) {
|
|
if(cat_sub == it->item) {
|
|
item = &*it;
|
|
b = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!b) {
|
|
tree_struct cat;
|
|
item->items.push_back(cat);
|
|
it = item->items.end();
|
|
--it;
|
|
it->parent = item;
|
|
item = &*it;
|
|
item->item = cat_sub;
|
|
}
|
|
if(cat_i == std::string::npos) {
|
|
break;
|
|
}
|
|
cat_i_prev = cat_i + 1;
|
|
cat_i = cat.find("/", cat_i_prev);
|
|
}
|
|
}
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < item->objects.size(); i3++) {
|
|
u = (Unit*) item->objects[i3];
|
|
if(CALCULATOR->units[i]->title() < u->title()) {
|
|
b = true;
|
|
item->objects.insert(item->objects.begin() + i3, (void*) CALCULATOR->units[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) item->objects.push_back((void*) CALCULATOR->units[i]);
|
|
}
|
|
}
|
|
|
|
unit_cats.sort();
|
|
|
|
}
|
|
void generate_variables_tree_struct() {
|
|
|
|
size_t cat_i, cat_i_prev;
|
|
bool b;
|
|
std::string str, cat, cat_sub;
|
|
Variable *v = NULL;
|
|
variable_cats.items.clear();
|
|
variable_cats.objects.clear();
|
|
variable_cats.parent = NULL;
|
|
ia_variables.clear();
|
|
std::list<tree_struct>::iterator it;
|
|
for(size_t i = 0; i < CALCULATOR->variables.size(); i++) {
|
|
if(!CALCULATOR->variables[i]->isActive()) {
|
|
//deactivated variable
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < ia_variables.size(); i3++) {
|
|
v = (Variable*) ia_variables[i3];
|
|
if(CALCULATOR->variables[i]->title() < v->title()) {
|
|
b = true;
|
|
ia_variables.insert(ia_variables.begin() + i3, (void*) CALCULATOR->variables[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) ia_variables.push_back((void*) CALCULATOR->variables[i]);
|
|
} else {
|
|
tree_struct *item = &variable_cats;
|
|
if(!CALCULATOR->variables[i]->category().empty()) {
|
|
cat = CALCULATOR->variables[i]->category();
|
|
cat_i = cat.find("/"); cat_i_prev = 0;
|
|
b = false;
|
|
while(true) {
|
|
if(cat_i == std::string::npos) {
|
|
cat_sub = cat.substr(cat_i_prev, cat.length() - cat_i_prev);
|
|
} else {
|
|
cat_sub = cat.substr(cat_i_prev, cat_i - cat_i_prev);
|
|
}
|
|
b = false;
|
|
for(it = item->items.begin(); it != item->items.end(); ++it) {
|
|
if(cat_sub == it->item) {
|
|
item = &*it;
|
|
b = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!b) {
|
|
tree_struct cat;
|
|
item->items.push_back(cat);
|
|
it = item->items.end();
|
|
--it;
|
|
it->parent = item;
|
|
item = &*it;
|
|
item->item = cat_sub;
|
|
}
|
|
if(cat_i == std::string::npos) {
|
|
break;
|
|
}
|
|
cat_i_prev = cat_i + 1;
|
|
cat_i = cat.find("/", cat_i_prev);
|
|
}
|
|
}
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < item->objects.size(); i3++) {
|
|
v = (Variable*) item->objects[i3];
|
|
if(CALCULATOR->variables[i]->title() < v->title()) {
|
|
b = true;
|
|
item->objects.insert(item->objects.begin() + i3, (void*) CALCULATOR->variables[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) item->objects.push_back((void*) CALCULATOR->variables[i]);
|
|
}
|
|
}
|
|
|
|
variable_cats.sort();
|
|
|
|
}
|
|
void generate_functions_tree_struct() {
|
|
|
|
size_t cat_i, cat_i_prev;
|
|
bool b;
|
|
std::string str, cat, cat_sub;
|
|
MathFunction *f = NULL;
|
|
function_cats.items.clear();
|
|
function_cats.objects.clear();
|
|
function_cats.parent = NULL;
|
|
ia_functions.clear();
|
|
std::list<tree_struct>::iterator it;
|
|
|
|
for(size_t i = 0; i < CALCULATOR->functions.size(); i++) {
|
|
if(!CALCULATOR->functions[i]->isActive()) {
|
|
//deactivated function
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < ia_functions.size(); i3++) {
|
|
f = (MathFunction*) ia_functions[i3];
|
|
if(CALCULATOR->functions[i]->title() < f->title()) {
|
|
b = true;
|
|
ia_functions.insert(ia_functions.begin() + i3, (void*) CALCULATOR->functions[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) ia_functions.push_back((void*) CALCULATOR->functions[i]);
|
|
} else {
|
|
tree_struct *item = &function_cats;
|
|
if(!CALCULATOR->functions[i]->category().empty()) {
|
|
cat = CALCULATOR->functions[i]->category();
|
|
cat_i = cat.find("/"); cat_i_prev = 0;
|
|
b = false;
|
|
while(true) {
|
|
if(cat_i == std::string::npos) {
|
|
cat_sub = cat.substr(cat_i_prev, cat.length() - cat_i_prev);
|
|
} else {
|
|
cat_sub = cat.substr(cat_i_prev, cat_i - cat_i_prev);
|
|
}
|
|
b = false;
|
|
for(it = item->items.begin(); it != item->items.end(); ++it) {
|
|
if(cat_sub == it->item) {
|
|
item = &*it;
|
|
b = true;
|
|
break;
|
|
}
|
|
}
|
|
if(!b) {
|
|
tree_struct cat;
|
|
item->items.push_back(cat);
|
|
it = item->items.end();
|
|
--it;
|
|
it->parent = item;
|
|
item = &*it;
|
|
item->item = cat_sub;
|
|
}
|
|
if(cat_i == std::string::npos) {
|
|
break;
|
|
}
|
|
cat_i_prev = cat_i + 1;
|
|
cat_i = cat.find("/", cat_i_prev);
|
|
}
|
|
}
|
|
b = false;
|
|
for(size_t i3 = 0; i3 < item->objects.size(); i3++) {
|
|
f = (MathFunction*) item->objects[i3];
|
|
if(CALCULATOR->functions[i]->title() < f->title()) {
|
|
b = true;
|
|
item->objects.insert(item->objects.begin() + i3, (void*) CALCULATOR->functions[i]);
|
|
break;
|
|
}
|
|
}
|
|
if(!b) item->objects.push_back((void*) CALCULATOR->functions[i]);
|
|
}
|
|
}
|
|
|
|
function_cats.sort();
|
|
|
|
}
|