PageRenderTime 56ms CodeModel.GetById 12ms RepoModel.GetById 1ms app.codeStats 1ms

/qalculate-kde-0.9.7/src/kqalculate.cpp

#
C++ | 6676 lines | 6122 code | 512 blank | 42 comment | 1344 complexity | 17355f2590d00cf9a7d9cb719f846222 MD5 | raw file
Possible License(s): GPL-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /***************************************************************************
    2. 

  2.  *   Copyright (C) 2005-2007 by Niklas Knutsson                            *
    3. 

  3.  *   nq@altern.org                                                         *
    4. 

  4.  *                                                                         *
    5. 

  5.  *   This program is free software; you can redistribute it and/or modify  *
    6. 

  6.  *   it under the terms of the GNU General Public License as published by  *
    7. 

  7.  *   the Free Software Foundation; either version 2 of the License, or     *
    8. 

  8.  *   (at your option) any later version.                                   *
    9. 

  9.  *                                                                         *
    10. 

  10.  *   This program is distributed in the hope that it will be useful,       *
    11. 

  11.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
    12. 

  12.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
    13. 

  13.  *   GNU General Public License for more details.                          *
    14. 

  14.  *                                                                         *
    15. 

  15.  *   You should have received a copy of the GNU General Public License     *
    16. 

  16.  *   along with this program; if not, write to the                         *
    17. 

  17.  *   Free Software Foundation, Inc.,                                       *
    18. 

  18.  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
    19. 

  19.  ***************************************************************************/
    20. 

  20. 

  21. #ifdef HAVE_CONFIG_H
    22. 

  22. #  include <config.h>
    23. 

  23. #endif
    24. 

  24. 

  25. #include <kdialog.h>
    26. 

  26. #include <klocale.h>
    27. 

  27. 

  28. #include "kqalculate.h"
    29. 

  29. #include "qalculateinsertfunctiondialog.h"
    30. 

  30. #include "qalculate_kde_utils.h"
    31. 

  31. #include "preferences.h"
    32. 

  32. #include "qalculatepreferencesdialog.h"
    33. 

  33. #include "qalculateimportcsvdialog.h"
    34. 

  34. #include "qalculateexportcsvdialog.h"
    35. 

  35. #include "qalculateexpressionedit.h"
    36. 

  36. #include "qalculateprecisiondialog.h"
    37. 

  37. #include "qalculatedecimalsdialog.h"
    38. 

  38. #include "qalculateeditvariabledialog.h"
    39. 

  39. #include "qalculateeditmatrixvectordialog.h"
    40. 

  40. #include "qalculateeditunitdialog.h"
    41. 

  41. #include "qalculateeditfunctiondialog.h"
    42. 

  42. #include "qalculateeditdatasetdialog.h"
    43. 

  43. #include "qalculateeditunknownvariabledialog.h"
    44. 

  44. #include "qalculatevariablesdialog.h"
    45. 

  45. #include "qalculatefunctionsdialog.h"
    46. 

  46. #include "qalculateunitsdialog.h"
    47. 

  47. #include "qalculatedatasetsdialog.h"
    48. 

  48. #include "qalculateconvertunitsdialog.h"
    49. 

  49. #include "qalculateconvertnumberbasesdialog.h"
    50. 

  50. #include "qalculateperiodictabledialog.h"
    51. 

  51. #include "qalculateplotdialog.h"
    52. 

  52. #include "qalculatesetbasedialog.h"
    53. 

  53. #include "qalculateinsertmatrixvectordialog.h"
    54. 

  54. 

  55. #include <kwin.h>
    56. 

  56. #include <kglobalsettings.h>
    57. 

  57. #include <kuniqueapplication.h>
    58. 

  58. #include <kstringhandler.h>
    59. 

  59. #include <qtable.h>
    60. 

  60. #include <kseparator.h>
    61. 

  61. #include <kiconloader.h>
    62. 

  62. #include <qframe.h>
    63. 

  63. #include <qvariant.h>
    64. 

  64. #include <qtooltip.h>
    65. 

  65. #include <qwhatsthis.h>
    66. 

  66. #include <qclipboard.h>
    67. 

  67. #include <qstylesheet.h>
    68. 

  68. #include <kcompletion.h>
    69. 

  69. #include <klineedit.h>
    70. 

  70. #include <qlabel.h>
    71. 

  71. #include <kmessagebox.h>
    72. 

  72. #include <qpixmap.h>
    73. 

  73. #include <qpicture.h>
    74. 

  74. #include <qpainter.h>
    75. 

  75. #include <qfontmetrics.h>
    76. 

  76. #include <sys/stat.h>
    77. 

  77. #include <unistd.h>
    78. 

  78. #include <time.h>
    79. 

  79. #include <math.h>
    80. 

  80. #include <dirent.h>
    81. 

  81. #include <pthread.h>
    82. 

  82. #include <qsimplerichtext.h>
    83. 

  83. #include <qstatusbar.h>
    84. 

  84. #include <qwidgetstack.h>
    85. 

  85. #include <ktextbrowser.h>
    86. 

  86. #include <kpushbutton.h>
    87. 

  87. #include "qalculateresultdisplay.h"
    88. 

  88. #include <qbitmap.h>
    89. 

  89. #include <qscrollview.h>
    90. 

  90. #include <qobject.h>
    91. 

  91. #include <kapplication.h>
    92. 

  92. #include <kaction.h>
    93. 

  93. #include <qspinbox.h>
    94. 

  94. #include <kprogress.h>
    95. 

  95. #include <kpopupmenu.h>
    96. 

  96. #include <kmenubar.h>
    97. 

  97. #include <qlayout.h>
    98. 

  98. #include <qtimer.h>
    99. 

  99. #include <kcompletionbox.h>
    100. 

  100. #include <qstringlist.h>
    101. 

  101. #include <qcombobox.h>
    102. 

  102. #include <ksystemtray.h>
    103. 

  103. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR > 1
    104. 

  104. #include <kactionclasses.h>
    105. 

  105. #endif
    106. 

  106. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR >= 4
    107. 

  107. #include <kaccelmanager.h>
    108. 

  108. #endif
    109. 

  109. #include <qbuttongroup.h>
    110. 

  110. #include <qvbuttongroup.h>
    111. 

  111. #include <qradiobutton.h>
    112. 

  112. #include <qgrid.h>
    113. 

  113. #include <kfiledialog.h>
    114. 

  114. #include <qimage.h>
    115. 

  115. #include <kaccel.h>
    116. 

  116. #include <kio/netaccess.h>
    117. 

  117. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR >= 2
    118. 

  118. #include <kinputdialog.h>
    119. 

  119. #endif
    120. 

  120. #include <kdeversion.h>
    121. 

  121. #include <qstyle.h>
    122. 

  122. #include <kglobalaccel.h>
    123. 

  123. #include <kkeydialog.h>
    124. 

  124. #include <kkeybutton.h>
    125. 

  125. #include <kcombobox.h>
    126. 

  126. 

  127. MathStructure *mstruct, *matrix_mstruct, *parsed_mstruct, *parsed_tostruct;
    128. 

  128. QString result_text, result_history_text, parsed_text;
    129. 

  129. QWidget *expressionWidget, *resultWidget, *statusWidget_l;
    130. 

  130. QWidget *topWidget;
    131. 

  131. KQalculate *mainWin = 0;
    132. 

  132. bool prev_result_approx;
    133. 

  133. extern bool close_to_systray;
    134. 

  134. extern bool display_expression_status;
    135. 

  135. extern QColor status_error_color;
    136. 

  136. extern QColor status_warning_color;
    137. 

  137. extern int use_icon_buttons;
    138. 

  138. extern bool enable_expression_completion;
    139. 

  139. 

  140. extern QString initial_history;
    141. 

  141. extern tree_struct function_cats, unit_cats, variable_cats;
    142. 

  142. extern vector<void*> ia_units, ia_variables, ia_functions;
    143. 

  143. extern vector<MathFunction*> recent_functions;
    144. 

  144. extern vector<Variable*> recent_variables;
    145. 

  145. extern vector<Unit*> recent_units;
    146. 

  146. vector<MathStructure> result_parts;
    147. 

  147. 

  148. KnownVariable *vans[5];
    149. 

  149. int vans_id_start[5];
    150. 

  150. int vans_id_end[5];
    151. 

  151. 

  152. extern PrintOptions printops;
    153. 

  153. extern EvaluationOptions evalops;
    154. 

  154. extern bool rpn_mode, rpn_keypad_only;
    155. 

  155. extern bool save_mode_on_exit, save_defs_on_exit;
    156. 

  156. 

  157. extern bool canplot;
    158. 

  158. 

  159. extern bool use_custom_result_font, use_custom_expression_font, use_custom_status_font;
    160. 

  160. extern QString custom_result_font, custom_expression_font, custom_status_font;
    161. 

  161. 

  162. extern QTimer *error_timer;
    163. 

  163. 

  164. extern QStringList expression_history;
    165. 

  165. 

  166. bool expression_has_changed, expression_has_changed2, had_errors_before, had_warnings_before, block_result_update;
    167. 

  167. 

  168. FILE *view_pipe_r, *view_pipe_w, *command_pipe_r, *command_pipe_w;
    169. 

  169. pthread_t view_thread, command_thread;
    170. 

  170. pthread_attr_t view_thread_attr, command_thread_attr;
    171. 

  171. bool b_busy, command_thread_started;
    172. 

  172. int saved_divisionline_height = 0;
    173. 

  173. uint initial_result_index = 0;
    174. 

  174. 

  175. extern bool show_keypad, show_history, show_stack;
    176. 

  176. 

  177. extern vector<mode_struct> modes;
    178. 

  178. 

  179. extern QValueVector<QString> inhistory;
    180. 

  180. extern QValueVector<int> inhistory_type;
    181. 

  181. extern QValueVector<int> inhistory_id;
    182. 

  182. extern int inhistory_current_id;
    183. 

  183. int initial_inhistory_index = 0;
    184. 

  184. 

  185. const MathStructure *KQalculate::getResultPart(int i) {
    186. 

  186. 	if(i < 1 || (size_t) i > result_parts.size()) return NULL;
    187. 

  187. 	return &result_parts[(size_t) i - 1];
    188. 

  188. }
    189. 

  189. 

  190. #if KDE_VERSION_MAJOR < 4 && KDE_VERSION_MINOR < 2
    191. 

  191. #include <kiconloader.h>
    192. 

  192. #include <kconfig.h>
    193. 

  193. QPixmap loadSystrayIcon(const QString &icon) {
    194. 

  194. 	KConfig *appCfg = kapp->config();
    195. 

  195. 	KConfigGroupSaver configSaver(appCfg, "System Tray");
    196. 

  196. 	int iconWidth = appCfg->readNumEntry("systrayIconWidth", 22);
    197. 

  197. 	return KGlobal::instance()->iconLoader()->loadIcon(icon, KIcon::Panel, iconWidth);
    198. 

  198. }
    199. 

  199. #endif
    200. 

  200. 

  201. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR >= 3
    202. 

  202. #define ICON_SIZE_SMALL_MEDIUM		KIcon::SizeSmallMedium
    203. 

  203. #else
    204. 

  204. #define ICON_SIZE_SMALL_MEDIUM		22
    205. 

  205. #endif
    206. 

  206. 

  207. ModeObject::ModeObject(int mode) : i_mode(mode) {}
    208. 

  208. void ModeObject::loadMode() {
    209. 

  209. 	mainWin->loadMode(i_mode);
    210. 

  210. }
    211. 

  211. 

  212. KQalculate::KQalculate(KUniqueApplication *parent, const char* name, WFlags fl) : KMainWindow(0, name, fl) {
    213. 

  213. 

  214. 	if(!name) setName("kqalculate");
    215. 

  215. 

  216. 	m_parent = parent;
    217. 

  217. 

  218. 	vans_id_start[0] = -1;
    219. 

  219. 	vans_id_end[0] = -1;
    220. 

  220. 	vans_id_start[1] = -1;
    221. 

  221. 	vans_id_end[1] = -1;
    222. 

  222. 	vans_id_start[2] = -1;
    223. 

  223. 	vans_id_end[2] = -1;
    224. 

  224. 	vans_id_start[3] = -1;
    225. 

  225. 	vans_id_end[3] = -1;
    226. 

  226. 	vans_id_start[4] = -1;
    227. 

  227. 	vans_id_end[4] = -1;
    228. 

  228. 	
    229. 

  229. 	QStyleSheet::setDefaultSheet(new QalculateStyleSheet());
    230. 

  230. 

  231. 	insert_matrix_dialog = NULL;
    232. 

  232. 	preferences_dialog = NULL;
    233. 

  233. 	precisionDialog = NULL;
    234. 

  234. 	decimalsDialog = NULL;
    235. 

  235. 	variable_edit_dialog = NULL;
    236. 

  236. 	store_dialog = NULL;
    237. 

  237. 	matrix_edit_dialog = NULL;
    238. 

  238. 	import_csv_dialog = NULL;
    239. 

  239. 	export_csv_dialog = NULL;
    240. 

  240. 	unit_edit_dialog = NULL;
    241. 

  241. 	function_edit_dialog = NULL;
    242. 

  242. 	dataset_edit_dialog = NULL;
    243. 

  243. 	unknown_edit_dialog = NULL;
    244. 

  244. 	variables_dialog = NULL;
    245. 

  245. 	functions_dialog = NULL;
    246. 

  246. 	units_dialog = NULL;
    247. 

  247. 	datasets_dialog = NULL;
    248. 

  248. 	convert_to_unit_expression_dialog = NULL;
    249. 

  249. 	convert_number_bases_dialog = NULL;
    250. 

  250. 	periodic_table_dialog = NULL;
    251. 

  251. 	plot_dialog = NULL;
    252. 

  252. 	set_base_dialog = NULL;
    253. 

  253. 	
    254. 

  254. 	prev_result_approx = false;
    255. 

  255. 	expression_has_changed = false;
    256. 

  256. 	expression_has_changed2 = false;
    257. 

  257. 	had_errors_before = false;
    258. 

  258. 	had_warnings_before = false;
    259. 

  259. 	block_result_update = false;
    260. 

  260. 	
    261. 

  261. 	history_height = 0;
    262. 

  262. 	
    263. 

  263. 	trayicon = NULL; 
    264. 

  264. 	ActionHideSystemTrayIcon = new KAction(i18n("Remove from System Tray"), "hidesystemtrayicon", 0, this, SLOT(hideSystemTrayIcon()), actionCollection(), "hide_system_tray_icon");
    265. 

  265. 	ActionHide = new KAction(i18n("Hide"), "hide", 0, this, SLOT(hide()), actionCollection(), "hide");
    266. 

  266. 	showSystemTrayIcon(close_to_systray);
    267. 

  267. 

  268. 	setCentralWidget(new QWidget(this));
    269. 

  269. 	QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget(), 11, 6);
    270. 

  270. 	mainLayout->setResizeMode(QLayout::Minimum);
    271. 

  271. 

  272. 	QHBoxLayout *topLayout = new QHBoxLayout(0, 0, 6);
    273. 

  273. 

  274. 	bool use_button_pixmaps = false;
    275. 

  275. 	if(use_icon_buttons > 0) {
    276. 

  276. 		use_button_pixmaps = true;
    277. 

  277. 	} else if(use_icon_buttons < 0) {
    278. 

  278. 		KConfig config("kdeglobals", true, false);	
    279. 

  279. 		config.setGroup("KDE");	
    280. 

  280. 		use_button_pixmaps = config.readBoolEntry("ShowIconsOnPushButtons", false);
    281. 

  281. 	}
    282. 

  282. 

  283. 	if(use_button_pixmaps) leftButtonsLayout = new QVBoxLayout(0, 0, 3);
    284. 

  284. 	else leftButtonsLayout = new QVBoxLayout(0, 0, 6);
    285. 

  285. 	if(use_button_pixmaps) executeButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("exec", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget());
    286. 

  286. 	else if(rpn_mode) executeButton = new QalculateButton(i18n("Enter"), centralWidget());
    287. 

  287. 	else executeButton = new QalculateButton(i18n("="), centralWidget());
    288. 

  288. 	executeButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    289. 

  289. 	if(rpn_mode) QToolTip::add(executeButton, i18n("Calculate expression and add to stack"));
    290. 

  290. 	else QToolTip::add(executeButton, i18n("Calculate expression"));
    291. 

  291. 	leftButtonsLayout->addWidget(executeButton);
    292. 

  292. 	leftButtonsSeparator = new KSeparator(Qt::Horizontal, centralWidget());
    293. 

  293. 	leftButtonsLayout->addWidget(leftButtonsSeparator);
    294. 

  294. 	if(use_button_pixmaps) leftButtonsSeparator->hide();
    295. 

  295. 	if(use_button_pixmaps) storeButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("filesaveas", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget());
    296. 

  296. 	else storeButton = new QalculateButton(i18n("Store"), centralWidget());
    297. 

  297. 	storeButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    298. 

  298. 	QToolTip::add(storeButton, i18n("Store result as variable"));
    299. 

  299. 	leftButtonsLayout->addWidget(storeButton);
    300. 

  300. 	if(use_button_pixmaps) convertButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("qalculate_convert", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", centralWidget());
    301. 

  301. 	else convertButton = new QalculateButton(i18n("Convert"), centralWidget());
    302. 

  302. 	convertButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    303. 

  303. 	QToolTip::add(convertButton, i18n("Convert units in result"));
    304. 

  304. 	leftButtonsLayout->addWidget(convertButton);
    305. 

  305. 	leftButtonsLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Minimum));
    306. 

  306. 	
    307. 

  307. 	QVBoxLayout *expressionLayout = new QVBoxLayout(0, 0, 0);
    308. 

  308. 	expressionEdit = new QalculateExpressionEdit(true, centralWidget());
    309. 

  309. 	expressionLayout->addWidget(expressionEdit);
    310. 

  310. 	expressionEdit->setFocus();
    311. 

  311. 	expressionEdit->expression_history = expression_history;
    312. 

  312. 	if(!enable_expression_completion) expressionEdit->disableCompletion();
    313. 

  313. 	QToolTip::add(expressionEdit, i18n("Enter expression here"));
    314. 

  314. 	QHBoxLayout *statusLayout = new QHBoxLayout(0, 0, 6);
    315. 

  315. 	statusLabel_l = new QalculateParseLabel(centralWidget());
    316. 

  316. 	statusLabel_l->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum, false);
    317. 

  317. 	statusLabel_l->setLineWidth(0);
    318. 

  318. 	statusLabel_l->setMargin(0);
    319. 

  319. 	statusLabel_l->setAlignment(int(QLabel::AlignTop | QLabel::AlignLeft));
    320. 

  320. 	if(!display_expression_status) statusLabel_l->hide();
    321. 

  321. 	statusLayout->addWidget(statusLabel_l);
    322. 

  322. 	statusLabel_r = new QLabel(i18n("status"), centralWidget());
    323. 

  323. 	statusLabel_r->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum, false);
    324. 

  324. 	statusLabel_r->setLineWidth(0);
    325. 

  325. 	statusLabel_r->setMargin(0);
    326. 

  326. 	statusLabel_r->setTextFormat(Qt::RichText);
    327. 

  327. 	statusLabel_r->setAlignment(int(QLabel::AlignTop | QLabel::AlignRight));	
    328. 

  328. 	statusLayout->addWidget(statusLabel_r);
    329. 

  329. 	expressionLayout->addLayout(statusLayout);
    330. 

  330. 	resultLabel = new QalculateResultDisplay(centralWidget());
    331. 

  331. 	resultLabel->setRightMargin(10);
    332. 

  332. 	expressionLayout->addWidget(resultLabel);
    333. 

  333. 	
    334. 

  334. 	topLayout->addLayout(expressionLayout);
    335. 

  335. 	topLayout->addLayout(leftButtonsLayout);
    336. 

  336. 	mainLayout->addLayout(topLayout);
    337. 

  337. 	
    338. 

  338. 	resultLabel->setWordWrap(QTextEdit::WidgetWidth);
    339. 

  339. 	resultLabel->setMargin(0);
    340. 

  340. 

  341. 	bottomLine = new KSeparator(Qt::Horizontal, centralWidget());
    342. 

  342. 	mainLayout->addWidget(bottomLine);
    343. 

  343. 

  344. 	mainStack = new QWidgetStack(centralWidget());
    345. 

  345. 	mainStack->setEnabled(true);
    346. 

  346. 	mainStack->setSizePolicy(QSizePolicy((QSizePolicy::SizeType) 5, (QSizePolicy::SizeType) 7, 0, 0, mainStack->sizePolicy().hasHeightForWidth()));
    347. 

  347. 

  348. 	keypadPage = new QWidget(mainStack);
    349. 

  349. 	QVBoxLayout *keypadPageLayout = new QVBoxLayout(keypadPage, 0, 12);
    350. 

  350. 	
    351. 

  351. 	keypadPageLayout->addWidget(new KSeparator(Qt::Horizontal, keypadPage));
    352. 

  352. 

  353. 	QHBoxLayout *keypadTopLayout = new QHBoxLayout(0, 0, 6);
    354. 

  354. 	kpExact = new QalculateButton(i18n("Exact"), keypadPage);
    355. 

  355. 	QToolTip::add(kpExact, i18n("Toggle exact mode"));
    356. 

  356. 	kpExact->setToggleButton(true);
    357. 

  357. 	keypadTopLayout->addWidget(kpExact);
    358. 

  358. 	kpFraction = new QalculateButton(i18n("Fraction"), keypadPage);
    359. 

  359. 	QToolTip::add(kpFraction, i18n("Toggle fractional display"));
    360. 

  360. 	kpFraction->setToggleButton(true);
    361. 

  361. 	keypadTopLayout->addWidget(kpFraction);
    362. 

  362. 	kpNumericCombo = new QComboBox(true, keypadPage);
    363. 

  363. 	QToolTip::add(kpNumericCombo, i18n("Numerical display"));
    364. 

  364. 	kpNumericCombo->setEditable(false);
    365. 

  365. 	keypadTopLayout->addWidget(kpNumericCombo);
    366. 

  366. 	kpNumericCombo->insertItem(i18n("Normal"));
    367. 

  367. 	kpNumericCombo->insertItem(i18n("Engineering"));
    368. 

  368. 	kpNumericCombo->insertItem(i18n("Scientific"));
    369. 

  369. 	kpNumericCombo->insertItem(i18n("Pure"));
    370. 

  370. 	kpNumericCombo->insertItem(i18n("Simple"));
    371. 

  371. 	kpBaseCombo = new QComboBox(true, keypadPage);
    372. 

  372. 	QToolTip::add(kpBaseCombo, i18n("Base in result"));
    373. 

  373. 	kpBaseCombo->setEditable(false);
    374. 

  374. 	keypadTopLayout->addWidget(kpBaseCombo);
    375. 

  375. 	keypadPageLayout->addLayout(keypadTopLayout);
    376. 

  376. 	kpBaseCombo->insertItem(i18n("Binary"));
    377. 

  377. 	kpBaseCombo->insertItem(i18n("Octal"));
    378. 

  378. 	kpBaseCombo->insertItem(i18n("Decimal"));
    379. 

  379. 	kpBaseCombo->insertItem(i18n("Hexadecimal"));
    380. 

  380. 	kpBaseCombo->insertItem(i18n("Sexagesimal"));
    381. 

  381. 	kpBaseCombo->insertItem(i18n("Time Format"));
    382. 

  382. 	kpBaseCombo->insertItem(i18n("Roman"));
    383. 

  383. 	kpBaseCombo->insertItem(i18n("Other..."));
    384. 

  384. 

  385. 	QHBoxLayout *keypadBottomLayout = new QHBoxLayout(0, 0, 24);
    386. 

  386. 

  387. 	QGridLayout *keypadFunctionsLayout = new QGridLayout(0, 5, 3, 0, 6);
    388. 

  388. 	
    389. 

  389. 	functionsButton = new QalculateButton(i18n("f(x)"), keypadPage);
    390. 

  390. 	QFont fb_font(functionsButton->font());
    391. 

  391. 	fb_font.setItalic(true);
    392. 

  392. 	functionsButton->setFont(fb_font);
    393. 

  393. 	QToolTip::add(functionsButton, i18n("Open functions manager"));
    394. 

  394. 	keypadFunctionsLayout->addWidget(functionsButton, 0, 0);
    395. 

  395. 	kpSqrt = new QalculateButton(i18n("sqrt"), keypadPage);
    396. 

  396. 	QToolTip::add(kpSqrt, i18n("Square root"));
    397. 

  397. 	keypadFunctionsLayout->addWidget(kpSqrt, 1, 0);
    398. 

  398. 	kpRaise = new QalculateButton(keypadPage);
    399. 

  399. 	kpRaise->setMarkup(i18n("x<sup>y</sup>"));
    400. 

  400. 	QToolTip::add(kpRaise, i18n("Raise (Ctrl+*)"));
    401. 

  401. 	keypadFunctionsLayout->addWidget(kpRaise, 0, 1);
    402. 

  402. 	kpSquare = new QalculateButton(keypadPage);
    403. 

  403. 	kpSquare->setMarkup(i18n("x<sup>2</sup>"));
    404. 

  404. 	QToolTip::add(kpSquare, i18n("Square"));
    405. 

  405. 	keypadFunctionsLayout->addWidget(kpSquare, 0, 2);
    406. 

  406. 	kpLog = new QalculateButton(i18n("log"), keypadPage);
    407. 

  407. 	QToolTip::add(kpLog, i18n("Base-10 logarithm"));
    408. 

  408. 	keypadFunctionsLayout->addWidget(kpLog, 1, 1);
    409. 

  409. 	kpLn = new QalculateButton(i18n("ln"), keypadPage);
    410. 

  410. 	QToolTip::add(kpLn, i18n("Natural logarithm"));
    411. 

  411. 	keypadFunctionsLayout->addWidget(kpLn, 1, 2);
    412. 

  412. 	kpFactorial = new QalculateButton(i18n("x!"), keypadPage);
    413. 

  413. 	QToolTip::add(kpFactorial, i18n("Factorial"));
    414. 

  414. 	keypadFunctionsLayout->addWidget(kpFactorial, 2, 0);
    415. 

  415. 	kpCos = new QalculateButton(i18n("cos"), keypadPage);
    416. 

  416. 	QToolTip::add(kpCos, i18n("Cosine"));
    417. 

  417. 	keypadFunctionsLayout->addWidget(kpCos, 2, 1);
    418. 

  418. 	kpTan = new QalculateButton(i18n("tan"), keypadPage);
    419. 

  419. 	QToolTip::add(kpTan, i18n("Tangent"));
    420. 

  420. 	keypadFunctionsLayout->addWidget(kpTan, 2, 2);
    421. 

  421. 	kpHyp = new QalculateButton(i18n("hyp"), keypadPage);
    422. 

  422. 	QToolTip::add(kpHyp, i18n("Toggle hyperbolic functions"));
    423. 

  423. 	kpHyp->setToggleButton(true);
    424. 

  424. 	keypadFunctionsLayout->addWidget(kpHyp, 3, 0);
    425. 

  425. 	kpInv = new QalculateButton(i18n("inv"), keypadPage);
    426. 

  426. 	QToolTip::add(kpInv, i18n("Toggle inverse functions"));
    427. 

  427. 	kpInv->setToggleButton(true);
    428. 

  428. 	keypadFunctionsLayout->addWidget(kpInv, 3, 1);
    429. 

  429. 	kpSin = new QalculateButton(i18n("sin"), keypadPage);
    430. 

  430. 	QToolTip::add(kpSin, i18n("Sine"));
    431. 

  431. 	keypadFunctionsLayout->addWidget(kpSin, 3, 2);
    432. 

  432. 	QHBoxLayout *keypadAngleLayout = new QHBoxLayout(0, 0, 6);
    433. 

  433. 	kpAngleGroup = new QButtonGroup();
    434. 

  434. 	kpAngleGroup->setExclusive(true);
    435. 

  435. 	kpDegreesButton = new QRadioButton(i18n("Deg"), keypadPage);
    436. 

  436. 	QToolTip::add(kpDegreesButton, i18n("Angle Unit: Degrees"));
    437. 

  437. 	kpAngleGroup->insert(kpDegreesButton, 0);
    438. 

  438. 	keypadAngleLayout->addWidget(kpDegreesButton);
    439. 

  439. 	kpRadiansButton = new QRadioButton(i18n("Rad"), keypadPage);
    440. 

  440. 	QToolTip::add(kpRadiansButton, i18n("Angle Unit: Radians"));
    441. 

  441. 	kpAngleGroup->insert(kpRadiansButton, 1);
    442. 

  442. 	keypadAngleLayout->addWidget(kpRadiansButton);
    443. 

  443. 	kpGradiansButton = new QRadioButton(i18n("Gra"), keypadPage);
    444. 

  444. 	QToolTip::add(kpGradiansButton, i18n("Angle Unit: Gradians"));
    445. 

  445. 	kpAngleGroup->insert(kpGradiansButton, 2);
    446. 

  446. 	keypadAngleLayout->addWidget(kpGradiansButton);
    447. 

  447. 	kpNoAngleUnitButton = new QRadioButton(i18n("None"), keypadPage);
    448. 

  448. 	kpAngleGroup->insert(kpNoAngleUnitButton, 3);
    449. 

  449. 	keypadAngleLayout->addWidget(kpNoAngleUnitButton);
    450. 

  450. 	kpNoAngleUnitButton->hide();
    451. 

  451. 	keypadAngleLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum));
    452. 

  452. 	keypadFunctionsLayout->addMultiCellLayout(keypadAngleLayout, 4, 4, 0, 2);
    453. 

  453. 	
    454. 

  454. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR >= 4	
    455. 

  455. 	KAcceleratorManager::setNoAccel(kpDegreesButton);
    456. 

  456. 	KAcceleratorManager::setNoAccel(kpRadiansButton);
    457. 

  457. 	KAcceleratorManager::setNoAccel(kpGradiansButton);
    458. 

  458. 	KAcceleratorManager::setNoAccel(kpNoAngleUnitButton);
    459. 

  459. #endif		
    460. 

  460. 	
    461. 

  461. 	keypadBottomLayout->addLayout(keypadFunctionsLayout);
    462. 

  462. 	
    463. 

  463. 	QGridLayout *keypadBasicsLayout = new QGridLayout(0, 1, 1, 0, 6);
    464. 

  464. 	kp7 = new QalculateButton(i18n("7"), keypadPage);
    465. 

  465. 	keypadBasicsLayout->addWidget(kp7, 0, 0);
    466. 

  466. 	kp8 = new QalculateButton(i18n("8"), keypadPage);
    467. 

  467. 	keypadBasicsLayout->addWidget(kp8, 0, 1);
    468. 

  468. 	kp9 = new QalculateButton(i18n("9"), keypadPage);
    469. 

  469. 	keypadBasicsLayout->addWidget(kp9, 0, 2);
    470. 

  470. 	kp4 = new QalculateButton(i18n("4"), keypadPage);
    471. 

  471. 	keypadBasicsLayout->addWidget(kp4, 1, 0);
    472. 

  472. 	kp5 = new QalculateButton(i18n("5"), keypadPage);
    473. 

  473. 	keypadBasicsLayout->addWidget(kp5, 1, 1);
    474. 

  474. 	kp6 = new QalculateButton(i18n("6"), keypadPage);
    475. 

  475. 	keypadBasicsLayout->addWidget(kp6, 1, 2);
    476. 

  476. 	kp1 = new QalculateButton(i18n("1"), keypadPage);
    477. 

  477. 	keypadBasicsLayout->addWidget(kp1, 2, 0);
    478. 

  478. 	kp2 = new QalculateButton(i18n("2"), keypadPage);
    479. 

  479. 	keypadBasicsLayout->addWidget(kp2, 2, 1);
    480. 

  480. 	kp3 = new QalculateButton(i18n("3"), keypadPage);
    481. 

  481. 	keypadBasicsLayout->addWidget(kp3, 2, 2);
    482. 

  482. 	kp0 = new QalculateButton(i18n("0"), keypadPage);
    483. 

  483. 	keypadBasicsLayout->addWidget(kp0, 3, 0);
    484. 

  484. 	kpDot = new QalculateButton(".", keypadPage);
    485. 

  485. 	QToolTip::add(kpDot, i18n("Decimal point"));
    486. 

  486. 	keypadBasicsLayout->addWidget(kpDot, 3, 1);
    487. 

  487. 	kpExp = new QalculateButton(i18n("EXP"), keypadPage);
    488. 

  488. 	QToolTip::add(kpExp, i18n("10^x (Ctrl+Shift+E)"));
    489. 

  489. 	keypadBasicsLayout->addWidget(kpExp, 3, 2);
    490. 

  490. 	
    491. 

  491. 	kpDel = new QalculateButton(i18n("Del"), keypadPage);
    492. 

  492. 	QToolTip::add(kpDel, i18n("Delete"));
    493. 

  493. 	keypadBasicsLayout->addWidget(kpDel, 0, 3);
    494. 

  494. 	kpClear = new QalculateButton(i18n("AC"), keypadPage);
    495. 

  495. 	QToolTip::add(kpClear, i18n("Clear"));
    496. 

  496. 	keypadBasicsLayout->addWidget(kpClear, 0, 4);
    497. 

  497. 	kpTimes = new QalculateButton("*", keypadPage);
    498. 

  498. 	QToolTip::add(kpTimes, i18n("Multiply"));
    499. 

  499. 	keypadBasicsLayout->addWidget(kpTimes, 1, 3);
    500. 

  500. 	kpDivision = new QalculateButton("/", keypadPage);
    501. 

  501. 	QToolTip::add(kpDivision, i18n("Divide"));
    502. 

  502. 	keypadBasicsLayout->addWidget(kpDivision, 1, 4);
    503. 

  503. 	kpPlus = new QalculateButton("+", keypadPage);
    504. 

  504. 	QToolTip::add(kpPlus, i18n("Add"));
    505. 

  505. 	keypadBasicsLayout->addWidget(kpPlus, 2, 3);
    506. 

  506. 	kpMinus = new QalculateButton("-", keypadPage);
    507. 

  507. 	QToolTip::add(kpMinus, i18n("Subtract"));
    508. 

  508. 	keypadBasicsLayout->addWidget(kpMinus, 2, 4);
    509. 

  509. 	kpAns = new QalculateButton(i18n("Ans"), keypadPage);
    510. 

  510. 	QToolTip::add(kpAns, i18n("Previous result"));
    511. 

  511. 	keypadBasicsLayout->addWidget(kpAns, 3, 3);
    512. 

  512. 	if(rpn_mode) kpEquals = new QalculateButton(i18n("Ent"), keypadPage);
    513. 

  513. 	else kpEquals = new QalculateButton(i18n("="), keypadPage);
    514. 

  514. 	if(rpn_mode) QToolTip::add(kpEquals, i18n("Calculate expression and add to stack"));
    515. 

  515. 	else QToolTip::add(kpEquals, i18n("Calculate expression"));
    516. 

  516. 	keypadBasicsLayout->addWidget(kpEquals, 3, 4);
    517. 

  517. 	keypadBottomLayout->addLayout(keypadBasicsLayout);
    518. 

  518. 	
    519. 

  519. 	keypadPageLayout->addLayout(keypadBottomLayout);
    520. 

  520. 

  521. 	keypadPageLayout->addWidget(new KSeparator(Qt::Horizontal, keypadPage));
    522. 

  522. 	mainStack->addWidget(keypadPage, 0);
    523. 

  523. 

  524. 	historyPage = new QWidget(mainStack, "historyPage");
    525. 

  525. 	QVBoxLayout *historyPageLayout = new QVBoxLayout(historyPage, 0, 0);
    526. 

  526. 	historyBrowser = new QalculateHistoryBrowser(historyPage, "historyBrowser");
    527. 

  527. 	historyBrowser->setTextFormat(KTextBrowser::RichText);
    528. 

  528. 	historyBrowser->setWordWrap(KTextBrowser::NoWrap);
    529. 

  529. 	historyPageLayout->addWidget(historyBrowser);
    530. 

  530. 	mainStack->addWidget(historyPage, 1);
    531. 

  531. 

  532. 	stackPage = new QWidget(mainStack, "stackPage");
    533. 

  533. 	QHBoxLayout *stackPageLayout = new QHBoxLayout(stackPage, 0, 6);
    534. 

  534. 	stackList = new QalculateRPNStackListView(stackPage, "stackList");
    535. 

  535. 	stackList->addColumn(i18n("Index"));
    536. 

  536. 	stackList->addColumn(i18n("Value"));
    537. 

  537. 	stackList->setColumnAlignment(0, Qt::AlignCenter);
    538. 

  538. 	stackList->setColumnAlignment(1, Qt::AlignRight);
    539. 

  539. 	stackList->setFullWidth(true);
    540. 

  540. 	stackList->setResizeMode(QListView::LastColumn);
    541. 

  541. 	stackList->setSelectionMode(QListView::Single);
    542. 

  542. 	stackList->setAllColumnsShowFocus(true);
    543. 

  543. 	stackList->setRootIsDecorated(false);
    544. 

  544. 	stackList->setItemsMovable(true);
    545. 

  545. 	stackList->setDragEnabled(true);
    546. 

  546. 	stackList->setAcceptDrops(true);
    547. 

  547. 	stackList->setSorting(-1);
    548. 

  548. 	stackList->setItemsRenameable(true);
    549. 

  549. 	stackList->setRenameable(1, true);
    550. 

  550. 	stackList->setRenameable(0, false);
    551. 

  551. 	stackPageLayout->addWidget(stackList);
    552. 

  552. 	if(use_button_pixmaps) stackPageButtonsLayout = new QVBoxLayout(stackPageLayout, 3);
    553. 

  553. 	else stackPageButtonsLayout = new QVBoxLayout(stackPageLayout, 6);
    554. 

  554. 	if(use_button_pixmaps) registerUpButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("up", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage);
    555. 

  555. 	else registerUpButton = new QalculateButton(i18n("Up"), stackPage);
    556. 

  556. 	QToolTip::add(registerUpButton, i18n("Move selected register up"));
    557. 

  557. 	registerUpButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    558. 

  558. 	stackPageButtonsLayout->addWidget(registerUpButton);
    559. 

  559. 	if(use_button_pixmaps) registerDownButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("down", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage);
    560. 

  560. 	else registerDownButton = new QalculateButton(i18n("Down"), stackPage);
    561. 

  561. 	QToolTip::add(registerDownButton, i18n("Move selected register down"));
    562. 

  562. 	registerDownButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    563. 

  563. 	stackPageButtonsLayout->addWidget(registerDownButton);
    564. 

  564. 	if(use_button_pixmaps) editRegisterButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("edit", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage);
    565. 

  565. 	else editRegisterButton = new QalculateButton(i18n("Edit"), stackPage);
    566. 

  566. 	QToolTip::add(editRegisterButton, i18n("Edit value of selected register"));
    567. 

  567. 	editRegisterButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    568. 

  568. 	stackPageButtonsLayout->addWidget(editRegisterButton);
    569. 

  569. 	if(use_button_pixmaps) deleteRegisterButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("editdelete", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage);
    570. 

  570. 	else deleteRegisterButton = new QalculateButton(i18n("Delete"), stackPage);
    571. 

  571. 	QToolTip::add(deleteRegisterButton, i18n("Delete selected register"));
    572. 

  572. 	deleteRegisterButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    573. 

  573. 	stackPageButtonsLayout->addWidget(deleteRegisterButton);
    574. 

  574. 	if(use_button_pixmaps) clearStackButton = new QalculateButton(KApplication::kApplication()->iconLoader()->loadIconSet("view_remove", KIcon::Small, ICON_SIZE_SMALL_MEDIUM), "", stackPage);
    575. 

  575. 	else clearStackButton = new QalculateButton(i18n("Clear"), stackPage);
    576. 

  576. 	QToolTip::add(clearStackButton, i18n("Clear the RPN stack"));
    577. 

  577. 	clearStackButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed, false);
    578. 

  578. 	registerUpButton->setEnabled(false);
    579. 

  579. 	registerDownButton->setEnabled(false);
    580. 

  580. 	editRegisterButton->setEnabled(false);
    581. 

  581. 	deleteRegisterButton->setEnabled(false);
    582. 

  582. 	clearStackButton->setEnabled(false);
    583. 

  583. 	stackPageButtonsLayout->addWidget(clearStackButton);
    584. 

  584. 	stackPageButtonsLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Minimum, QSizePolicy::Expanding));
    585. 

  585. 	mainStack->addWidget(stackPage, 2);
    586. 

  586. 

  587. 	updateButtonWidths();
    588. 

  588. 

  589. 	mainLayout->addWidget(mainStack);
    590. 

  590. 	
    591. 

  591. 	QHBoxLayout *bottomLayout = new QHBoxLayout(0, 0, 6);
    592. 

  592. 	keypadButton = new QPushButton(i18n("Keypad"), centralWidget());
    593. 

  593. 	QToolTip::add(keypadButton, i18n("Show/hide keypad"));
    594. 

  594. 	keypadButton->setToggleButton(true);
    595. 

  595. 	bottomLayout->addWidget(keypadButton);
    596. 

  596. 	historyButton = new QPushButton(i18n("History"), centralWidget());
    597. 

  597. 	QToolTip::add(historyButton, i18n("Show/hide history"));
    598. 

  598. 	historyButton->setToggleButton(true);
    599. 

  599. 	bottomLayout->addWidget(historyButton);
    600. 

  600. 	stackButton = new QPushButton(i18n("RPN Stack"), centralWidget());
    601. 

  601. 	QToolTip::add(stackButton, i18n("Show/hide RPN stack"));
    602. 

  602. 	stackButton->setToggleButton(true);
    603. 

  603. 	bottomLayout->addWidget(stackButton);
    604. 

  604. 	if(!rpn_mode) stackButton->hide();
    605. 

  605. 	bottomLayout->addItem(new QSpacerItem(1, 1, QSizePolicy::Expanding, QSizePolicy::Minimum));
    606. 

  606. 	mainLayout->addLayout(bottomLayout);
    607. 

  607. 

  608. 	connect(stackList, SIGNAL(selectionChanged()), this, SLOT(registerSelected()));
    609. 

  609. 	connect(stackList, SIGNAL(itemRenamed(QListViewItem*)), this, SLOT(stackRegisterSet(QListViewItem*)));
    610. 

  610. 	connect(stackList, SIGNAL(moved()), this, SLOT(stackRegisterMoved()));
    611. 

  611. 	connect(stackList, SIGNAL(contextMenu(KListView*, QListViewItem*, const QPoint&)), this, SLOT(popupStackMenu(KListView*, QListViewItem*, const QPoint&)));
    612. 

  612. 	connect(registerUpButton, SIGNAL(clicked()), this, SLOT(registerUp()));
    613. 

  613. 	connect(registerDownButton, SIGNAL(clicked()), this, SLOT(registerDown()));
    614. 

  614. 	connect(editRegisterButton, SIGNAL(clicked()), this, SLOT(editRegister()));
    615. 

  615. 	connect(deleteRegisterButton, SIGNAL(clicked()), this, SLOT(deleteRegister()));
    616. 

  616. 	connect(clearStackButton, SIGNAL(clicked()), this, SLOT(clearStack()));
    617. 

  617. 	connect(stackButton, SIGNAL(toggled(bool)), this, SLOT(toggleStack(bool)));
    618. 

  618. 	connect(historyButton, SIGNAL(toggled(bool)), this, SLOT(toggleHistory(bool)));
    619. 

  619. 	connect(keypadButton, SIGNAL(toggled(bool)), this, SLOT(toggleKeypad(bool)));
    620. 

  620. 	connect(kp0, SIGNAL(clicked()), this, SLOT(insertKP0()));
    621. 

  621. 	connect(kp1, SIGNAL(clicked()), this, SLOT(insertKP1()));
    622. 

  622. 	connect(kp2, SIGNAL(clicked()), this, SLOT(insertKP2()));
    623. 

  623. 	connect(kp3, SIGNAL(clicked()), this, SLOT(insertKP3()));
    624. 

  624. 	connect(kp4, SIGNAL(clicked()), this, SLOT(insertKP4()));
    625. 

  625. 	connect(kp5, SIGNAL(clicked()), this, SLOT(insertKP5()));
    626. 

  626. 	connect(kp6, SIGNAL(clicked()), this, SLOT(insertKP6()));
    627. 

  627. 	connect(kp7, SIGNAL(clicked()), this, SLOT(insertKP7()));
    628. 

  628. 	connect(kp8, SIGNAL(clicked()), this, SLOT(insertKP8()));
    629. 

  629. 	connect(kp9, SIGNAL(clicked()), this, SLOT(insertKP9()));
    630. 

  630. 	connect(kpDot, SIGNAL(clicked()), this, SLOT(insertDot()));
    631. 

  631. 	connect(kpExp, SIGNAL(clicked()), this, SLOT(insertExp()));
    632. 

  632. 	connect(kpAns, SIGNAL(clicked()), this, SLOT(insertAns()));
    633. 

  633. 	connect(kpEquals, SIGNAL(clicked()), this, SLOT(execute()));
    634. 

  634. 	connect(kpPlus, SIGNAL(clicked()), this, SLOT(insertPlus()));
    635. 

  635. 	connect(kpMinus, SIGNAL(clicked()), this, SLOT(insertMinus()));
    636. 

  636. 	connect(kpTimes, SIGNAL(clicked()), this, SLOT(insertTimes()));
    637. 

  637. 	connect(kpDivision, SIGNAL(clicked()), this, SLOT(insertDivision()));
    638. 

  638. 	connect(kpDel, SIGNAL(clicked()), this, SLOT(expressionDel()));
    639. 

  639. 	connect(kpClear, SIGNAL(clicked()), this, SLOT(clearExpression()));
    640. 

  640. 	connect(kpSin, SIGNAL(clicked()), this, SLOT(insertSin()));
    641. 

  641. 	connect(kpCos, SIGNAL(clicked()), this, SLOT(insertCos()));
    642. 

  642. 	connect(kpTan, SIGNAL(clicked()), this, SLOT(insertTan()));
    643. 

  643. 	connect(kpSqrt, SIGNAL(clicked()), this, SLOT(insertSqrt()));
    644. 

  644. 	connect(kpLog, SIGNAL(clicked()), this, SLOT(insertLog()));
    645. 

  645. 	connect(kpLn, SIGNAL(clicked()), this, SLOT(insertLn()));
    646. 

  646. 	connect(kpRaise, SIGNAL(clicked()), this, SLOT(insertRaise()));
    647. 

  647. 	connect(kpSquare, SIGNAL(clicked()), this, SLOT(insertSquare()));
    648. 

  648. 	connect(kpFraction, SIGNAL(toggled(bool)), this, SLOT(setFractionMode(bool)));
    649. 

  649. 	connect(kpExact, SIGNAL(toggled(bool)), this, SLOT(setExactMode(bool)));
    650. 

  650. 	connect(kpAngleGroup, SIGNAL(clicked(int)), this, SLOT(kpSetAngleUnit(int)));
    651. 

  651. 	connect(kpBaseCombo->listBox(), SIGNAL(selected(int)), this, SLOT(kpSetBaseSelected(int)));
    652. 

  652. 	connect(kpBaseCombo, SIGNAL(activated(int)), this, SLOT(kpSetBase(int)));
    653. 

  653. 	connect(kpNumericCombo, SIGNAL(activated(int)), this, SLOT(kpSetNumericalMode(int)));
    654. 

  654. 	//connect(kpMod, SIGNAL(clicked()), this, SLOT(insertMod()));
    655. 

  655. 	connect(kpFactorial, SIGNAL(clicked()), this, SLOT(insertFactorial()));
    656. 

  656. 	//connect(expressionEdit, SIGNAL(returnPressed()), this, SLOT(execute()));
    657. 

  657. 	connect(expressionEdit, SIGNAL(textChanged(const QString&)), this, SLOT(onExpressionChanged()));
    658. 

  658. 	connect(storeButton, SIGNAL(clicked()), this, SLOT(storeResult()));
    659. 

  659. 	connect(executeButton, SIGNAL(clicked()), this, SLOT(execute()));
    660. 

  660. 	connect(convertButton, SIGNAL(clicked()), this, SLOT(convertToUnitExpression()));
    661. 

  661. 	connect(functionsButton, SIGNAL(clicked()), this, SLOT(manageFunctions()));
    662. 

  662. 	connect(expressionEdit, SIGNAL(cursorMoved()), this, SLOT(displayParseStatus()));
    663. 

  663. 	connect(expressionEdit->qalculateCompletionBox, SIGNAL(hidden()), statusLabel_l, SLOT(update()));
    664. 

  664. 

  665. 	//tab order
    666. 

  666. 	setTabOrder(expressionEdit, resultLabel);
    667. 

  667. 	setTabOrder(resultLabel, historyBrowser);
    668. 

  668. 	setTabOrder(historyBrowser, keypadButton);
    669. 

  669. 	setTabOrder(keypadButton, historyButton);
    670. 

  670. 	setTabOrder(historyButton, stackButton);
    671. 

  671. 

  672. 	 if(show_stack && rpn_mode) {
    673. 

  673. 		bottomLine->hide();
    674. 

  674. 		stackButton->setOn(true);
    675. 

  675. 		mainStack->raiseWidget(2);
    676. 

  676. 		mainStack->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, false);
    677. 

  677. 		resultLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum, false);
    678. 

  678. 	} else if(show_keypad) {
    679. 

  679. 		bottomLine->hide();
    680. 

  680. 		keypadButton->setOn(true);
    681. 

  681. 		mainStack->raiseWidget(0);
    682. 

  682. 		mainStack->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum, false);
    683. 

  683. 		resultLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, false);
    684. 

  684. 	} else if(show_history) {
    685. 

  685. 		bottomLine->hide();
    686. 

  686. 		historyButton->setOn(true);
    687. 

  687. 		mainStack->raiseWidget(1);
    688. 

  688. 		mainStack->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, false);
    689. 

  689. 		resultLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum, false);
    690. 

  690. 	} else {
    691. 

  691. 		mainStack->hide();
    692. 

  692. 		mainStack->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum, false);
    693. 

  693. 		resultLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding, false);
    694. 

  694. 	}
    695. 

  695. 	
    696. 

  696. 	initial_history = "";
    697. 

  697. 

  698. 	for(QValueVector<QString>::size_type i = 0; i < inhistory.size(); i++) {
    699. 

  699. 		switch(inhistory_type[i]) {
    700. 

  700. 			case QALCULATE_HISTORY_EXPRESSION: {
    701. 

  701. 				if(i != 0) {
    702. 

  702. 					initial_history += "<br><hr>";
    703. 

  703. 				}
    704. 

  704. 				initial_history += "<a name=\"";
    705. 

  705. 				initial_history += QString::number(inhistory_id[i]);
    706. 

  706. 				initial_history += "\">";
    707. 

  707. 				initial_history += inhistory[i];
    708. 

  708. 				initial_history += "</a>";
    709. 

  709. 				initial_history += " ";
    710. 

  710. 				break;
    711. 

  711. 			}
    712. 

  712. 			case QALCULATE_HISTORY_REGISTER_MOVED: {
    713. 

  713. 				if(i != 0) {
    714. 

  714. 					initial_history += "<br><hr>";
    715. 

  715. 				}
    716. 

  716. 				initial_history += i18n("RPN Register Moved");
    717. 

  717. 				initial_history += "<br>";
    718. 

  718. 				break;
    719. 

  719. 			}
    720. 

  720. 			case QALCULATE_HISTORY_TRANSFORMATION: {
    721. 

  721. 				initial_history += "<i>";
    722. 

  722. 				initial_history += "<b>";
    723. 

  723. 				initial_history += inhistory[i];
    724. 

  724. 				initial_history += "</i>";
    725. 

  725. 				initial_history += ": ";
    726. 

  726. 				break;
    727. 

  727. 			}
    728. 

  728. 			case QALCULATE_HISTORY_RESULT: {
    729. 

  729. 				initial_history += "<a name=\"";
    730. 

  730. 				initial_history += QString::number(inhistory_id[i]);
    731. 

  731. 				initial_history += "\">";
    732. 

  732. 				initial_history += "= ";
    733. 

  733. 				initial_history += "</a>";
    734. 

  734. 				initial_history += "<b>";
    735. 

  735. 				initial_history += "<a name=\"";
    736. 

  736. 				initial_history += QString::number(inhistory_id[i]);
    737. 

  737. 				initial_history += "\">";
    738. 

  738. 				initial_history += inhistory[i];
    739. 

  739. 				initial_history += "</a>";
    740. 

  740. 				initial_history += "</b>";
    741. 

  741. 				initial_history += "<br>";
    742. 

  742. 				break;
    743. 

  743. 			}
    744. 

  744. 			case QALCULATE_HISTORY_RESULT_APPROXIMATE: {
    745. 

  745. 				initial_history += "<a name=\"";
    746. 

  746. 				initial_history += QString::number(inhistory_id[i]);
    747. 

  747. 				initial_history += "\">";
    748. 

  748. 				if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) {
    749. 

  749. 					initial_history += SIGN_ALMOST_EQUAL " ";
    750. 

  750. 				} else {
    751. 

  751. 					initial_history += "= ";
    752. 

  752. 					initial_history += i18n("approx.");
    753. 

  753. 					initial_history += " ";
    754. 

  754. 				}
    755. 

  755. 				initial_history += "</a>";
    756. 

  756. 				initial_history += "<b>";
    757. 

  757. 				initial_history += "<a name=\"";
    758. 

  758. 				initial_history += QString::number(inhistory_id[i]);
    759. 

  759. 				initial_history += "\">";
    760. 

  760. 				initial_history += inhistory[i];
    761. 

  761. 				initial_history += "</a>";
    762. 

  762. 				initial_history += "</b>";
    763. 

  763. 				initial_history += "<br>";
    764. 

  764. 				break;
    765. 

  765. 			}
    766. 

  766. 			case QALCULATE_HISTORY_PARSE: {
    767. 

  767. 				initial_history += "&nbsp;&nbsp;= ";
    768. 

  768. 				initial_history += "<font color=\"gray40\"><i>";
    769. 

  769. 				initial_history += "<a name=\"";
    770. 

  770. 				initial_history += QString::number(inhistory_id[i]);
    771. 

  771. 				initial_history += "\">";
    772. 

  772. 				initial_history += inhistory[i];
    773. 

  773. 				initial_history += "</a>";
    774. 

  774. 				initial_history += "</i></font>";
    775. 

  775. 				initial_history += "<br>";
    776. 

  776. 				break;
    777. 

  777. 			}
    778. 

  778. 			case QALCULATE_HISTORY_PARSE_APPROXIMATE: {
    779. 

  779. 				initial_history += "&nbsp;&nbsp;";
    780. 

  780. 				if(printops.use_unicode_signs && can_display_unicode_string_function(SIGN_ALMOST_EQUAL, (void*) historyBrowser)) {
    781. 

  781. 					initial_history += SIGN_ALMOST_EQUAL " ";
    782. 

  782. 				} else {
    783. 

  783. 					initial_history += "= ";
    784. 

  784. 					initial_history += i18n("approx.");
    785. 

  785. 					initial_history += " ";
    786. 

  786. 				}
    787. 

  787. 				initial_history += "<font color=\"gray40\"><i>";
    788. 

  788. 				initial_history += "<a name=\"";
    789. 

  789. 				initial_history += QString::number(inhistory_id[i]);
    790. 

  790. 				initial_history += "\">";
    791. 

  791. 				initial_history += inhistory[i];
    792. 

  792. 				initial_history += "</a>";
    793. 

  793. 				initial_history += "</i></font>";
    794. 

  794. 				initial_history += "<br>";
    795. 

  795. 				break;
    796. 

  796. 			}
    797. 

  797. 			case QALCULATE_HISTORY_WARNING: {
    798. 

  798. 				initial_history += "<font color=\"blue\">";
    799. 

  799. 				initial_history += "- ";
    800. 

  800. 				initial_history += inhistory[i];
    801. 

  801. 				initial_history += "</font>";
    802. 

  802. 				initial_history += "<br>";
    803. 

  803. 				break;
    804. 

  804. 			}
    805. 

  805. 			case QALCULATE_HISTORY_ERROR: {
    806. 

  806. 				initial_history += "<font color=\"red\">";
    807. 

  807. 				initial_history += "- ";
    808. 

  808. 				initial_history += inhistory[i];
    809. 

  809. 				initial_history += "</font>";
    810. 

  810. 				initial_history += "<br>";
    811. 

  811. 				break;
    812. 

  812. 			}
    813. 

  813. 			case QALCULATE_HISTORY_OLD: {
    814. 

  814. 				initial_history += inhistory[i];
    815. 

  815. 				initial_history += "<br>";
    816. 

  816. 				break;
    817. 

  817. 			}
    818. 

  818. 		}	
    819. 

  819. 	}
    820. 

  820. 

  821. 	historyBrowser->setText(initial_history);
    822. 

  822. 	initial_history = "";
    823. 

  823. 

  824. 	if(use_custom_result_font) {
    825. 

  825. 		QFont new_font(resultLabel->font());
    826. 

  826. 		new_font.fromString(custom_result_font);
    827. 

  827. 		resultLabel->setFont(new_font);
    828. 

  828. 	} else {
    829. 

  829. 		resultLabel->unsetFont();
    830. 

  830. 	}
    831. 

  831. 	if(use_custom_expression_font) {
    832. 

  832. 		QFont new_font(expressionEdit->font());
    833. 

  833. 		new_font.fromString(custom_expression_font);
    834. 

  834. 		expressionEdit->setFont(new_font);
    835. 

  835. 	} else {
    836. 

  836. 		expressionEdit->unsetFont();
    837. 

  837. 	}
    838. 

  838. 	updateStatusLabelFonts();
    839. 

  839. 	
    840. 

  840. 	set_unicode_buttons();
    841. 

  841. 

  842. 	setupActions();
    843. 

  843. 

  844. 	stackMenu = new QPopupMenu(this);
    845. 

  845. 	ActionEditRegister->plug(stackMenu);
    846. 

  846. 	ActionDeleteRegister->plug(stackMenu);
    847. 

  847. 	stackMenu->insertSeparator();
    848. 

  848. 	ActionClearStack->plug(stackMenu);
    849. 

  849. 

  850. 	update_status_text();
    851. 

  851. 

  852. 	bottomLine->setMinimumWidth(1000);
    853. 

  853. 

  854. 	createGUI("qalculate_kdeui.rc");
    855. 

  855. 	
    856. 

  856. 	menuBar()->sizeHint();
    857. 

  857. 	int h = menuBar()->height();
    858. 

  858. 	int w = 300;
    859. 

  859. 	while(menuBar()->heightForWidth(w) > h && w < 1000) {
    860. 

  860. 		w += 10;
    861. 

  861. 	}
    862. 

  862. 	if(w >= 1000) {
    863. 

  863. 		bottomLine->setMinimumWidth(0);
    864. 

  864. 		w = 0;
    865. 

  865. 	} else {
    866. 

  866. 		bottomLine->setMinimumWidth(w - 22);
    867. 

  867. 	}
    868. 

  868. 

  869. 	if(!isShown()) adjustSize();
    870. 

  870. 	setAutoSaveSettings();
    871. 

  871. 	
    872. 

  872. 	if(show_history || (rpn_mode && show_stack)) {
    873. 

  873. 		resize(QSize(10, height()).expandedTo(minimumSizeHint()));
    874. 

  874. 	} else if(show_keypad) {
    875. 

  875. 		resize(minimumSizeHint());
    876. 

  876. 	} else {
    877. 

  877. 		resize(QSize(width(), 10).expandedTo(minimumSizeHint()));
    878. 

  878. 	}
    879. 

  879. 

  880. 	menu_functions = (QPopupMenu*) factory()->container("functions", this);
    881. 

  881. 	menu_variables = (QPopupMenu*) factory()->container("variables", this);
    882. 

  882. 	menu_units = (QPopupMenu*) factory()->container("units", this);
    883. 

  883. 	menu_to_unit = (QPopupMenu*) factory()->container("convert_to_unit", this);
    884. 

  884. 	menu_set_prefix = (QPopupMenu*) factory()->container("set_prefix", this);
    885. 

  885. 	menu_modes = (QPopupMenu*) factory()->container("modes", this);
    886. 

  886. 	
    887. 

  887. 	QObject::connect(menu_modes, SIGNAL(activated(int)), this, SLOT(onModesMenuItemActivated(int)));
    888. 

  888. 	for(size_t i = 0; i < modes.size(); i++) {
    889. 

  889. 		menu_modes->insertItem(modes[i].name, -1, i);
    890. 

  890. 		if(i > 1) {
    891. 

  891. 			ModeObject *mo = new ModeObject(i);
    892. 

  892. 			mo->i_mode = i;
    893. 

  893. 			mode_objects.push_back(mo);
    894. 

  894. 			accel()->insert(QString("Load mode: ") + modes[i].name, i18n("Load meta mode: %1").arg(modes[i].name), QString::null, modes[i].shortcut, mo, SLOT(loadMode()));
    895. 

  895. 		}
    896. 

  896. 	}
    897. 

  897. 

  898. 	QObject::connect(menu_functions, SIGNAL(activated(int)), this, SLOT(onFunctionMenuItemActivated(int)));
    899. 

  899. 	QObject::connect(menu_variables, SIGNAL(activated(int)), this, SLOT(onVariableMenuItemActivated(int)));
    900. 

  900. 	QObject::connect(menu_units, SIGNAL(activated(int)), this, SLOT(onUnitMenuItemActivated(int)));
    901. 

  901. 	QObject::connect(menu_to_unit, SIGNAL(activated(int)), this, SLOT(onConvertToUnitMenuItemActivated(int)));
    902. 

  902. 	QObject::connect(menu_set_prefix, SIGNAL(activated(int)), this, SLOT(onSetPrefixMenuItemActivated(int)));
    903. 

  903. 

  904. }
    905. 

  905. 

  906. KQalculate::~KQalculate() {}
    907. 

  907. 

  908. void KQalculate::updateStatusLabelFonts() {
    909. 

  909. 	if(use_custom_status_font) {
    910. 

  910. 		QFont new_font(statusLabel_l->font());
    911. 

  911. 		new_font.fromString(custom_status_font);
    912. 

  912. 		statusLabel_l->setFont(new_font);
    913. 

  913. 		new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.2);
    914. 

  914. 		statusLabel_r->setFont(new_font);
    915. 

  915. 	} else {
    916. 

  916. 		statusLabel_l->unsetFont();
    917. 

  917. 		statusLabel_r->unsetFont();
    918. 

  918. 		QFont new_font = statusLabel_l->font();
    919. 

  919. 		new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.2);
    920. 

  920. 		statusLabel_l->setFont(new_font);
    921. 

  921. 		new_font = statusLabel_r->font();
    922. 

  922. 		new_font.setPointSizeFloat(new_font.pointSizeFloat() / 1.44);
    923. 

  923. 		statusLabel_r->setFont(new_font);
    924. 

  924. 	}
    925. 

  925. }
    926. 

  926. 

  927. void KQalculate::updateButtonWidths() {
    928. 

  928. 	int button_width = executeButton->sizeHint().width();
    929. 

  929. 	if(storeButton->sizeHint().width() > button_width) button_width = storeButton->sizeHint().width();
    930. 

  930. 	if(convertButton->sizeHint().width() > button_width) button_width = convertButton->sizeHint().width();
    931. 

  931. 	if(registerUpButton->sizeHint().width() > button_width) button_width = registerUpButton->sizeHint().width();
    932. 

  932. 	if(registerDownButton->sizeHint().width() > button_width) button_width = registerDownButton->sizeHint().width();
    933. 

  933. 	if(editRegisterButton->sizeHint().width() > button_width) button_width = editRegisterButton->sizeHint().width();
    934. 

  934. 	if(deleteRegisterButton->sizeHint().width() > button_width) button_width = deleteRegisterButton->sizeHint().width();
    935. 

  935. 	if(clearStackButton->sizeHint().width() > button_width) button_width = clearStackButton->sizeHint().width();
    936. 

  936. 	clearStackButton->setMinimumWidth(button_width);
    937. 

  937. 	executeButton->setMinimumWidth(button_width);
    938. 

  938. }
    939. 

  939. 

  940. void KQalculate::fontChange(const QFont &old_font) {
    941. 

  941. 	updateStatusLabelFonts();
    942. 

  942. 	functionsButton->unsetFont();
    943. 

  943. 	QFont fb_font(functionsButton->font());
    944. 

  944. 	fb_font.setItalic(true);
    945. 

  945. 	functionsButton->setFont(fb_font);
    946. 

  946. 	kpSquare->setMarkup(i18n("x<sup>2</sup>"));
    947. 

  947. 	kpRaise->setMarkup(i18n("x<sup>y</sup>"));
    948. 

  948. 	result_display_updated();
    949. 

  949. 	KMainWindow::fontChange(old_font);
    950. 

  950. 	updateButtonWidths();
    951. 

  951. }
    952. 

  952. 

  953. void KQalculate::showSystemTrayIcon(bool do_show) {
    954. 

  954. 	if(do_show && !trayicon) {
    955. 

  955. 		trayicon = new KSystemTray(this);
    956. 

  956. 		QObject::connect(trayicon, SIGNAL(quitSelected()), qApp, SLOT(quit()));
    957. 

  957. #if KDE_VERSION_MAJOR < 4 && KDE_VERSION_MINOR < 2	
    958. 

  958. 		trayicon->setPixmap(loadSystrayIcon(PACKAGE));
    959. 

  959. #else
    960. 

  960. 		trayicon->setPixmap(trayicon->loadIcon(PACKAGE));
    961. 

  961. #endif
    962. 

  962. #if KDE_VERSION_MAJOR > 3 || KDE_VERSION_MINOR >= 2
    963. 

  963. 		KPopupMenu* traypop = trayicon->contextMenu();
    964. 

  964. 		ActionHideSystemTrayIcon->plug(traypop, 1);
    965. 

  965. #endif
    966. 

  966. 		QToolTip::add(trayicon, i18n("Qalculate! - Scientific Calculator"));
    967. 

  967. 	}
    968. 

  968. 	if(do_show) {
    969. 

  969. 		trayicon->show();
    970. 

  970. 	} else if(trayicon) {
    971. 

  971. 		trayicon->hide();
    972. 

  972. 	}
    973. 

  973. }
    974. 

  974. void KQalculate::hideSystemTrayIcon() {
    975. 

  975. 	showSystemTrayIcon(false);
    976. 

  976. 	close_to_systray = false;
    977. 

  977. 	show();
    978. 

  978. }
    979. 

  979. 

  980. #define SET_TOGGLE_ACTION(action, value)	action->blockSignals(true); action->setChecked(value); action->blockSignals(false);
    981. 

  981. #define SET_TOGGLE_ACTION_ON(action)	action->blockSignals(true); action->setChecked(true); action->blockSignals(false);
    982. 

  982. 

  983. void KQalculate::setupActions() {
    984. 

  984. 

  985. 	ActionNewVariable = new KAction(i18n("Variable"), "filenew", 0, this, SLOT(newVariable()), actionCollection(), "new_variable");
    986. 

  986. 	ActionNewMatrix = new KAction(i18n("Matrix"), "filenew", 0, this, SLOT(newMatrix()), actionCollection(), "new_matrix");
    987. 

  987. 	ActionNewVector = new KAction(i18n("Vector"), "filenew", 0, this, SLOT(newVector()), actionCollection(), "new_vector");
    988. 

  988. 	ActionNewUnknownVariable = new KAction(i18n("Unknown Variable"), "filenew", 0, this, SLOT(newUnknownVariable()), actionCollection(), "new_unknown_variable");
    989. 

  989. 	ActionNewFunction = new KAction(i18n("Function"), "filenew", 0, this, SLOT(newFunction()), actionCollection(), "new_function");
    990. 

  990. 	ActionNewDataSet = new KAction(i18n("Data Set"), "filenew", 0, this, SLOT(newDataSet()), actionCollection(), "new_data_set");
    991. 

  991. 	ActionNewUnit = new KAction(i18n("Unit"), "filenew", 0, this, SLOT(newUnit()), actionCollection(), "new_unit");
    992. 

  992. 	ActionImportCSVFile = new KAction(i18n("Import CSV File..."), "fileimport", 0, this, SLOT(importCSVFile()), actionCollection(), "import_csv_file");
    993. 

  993. 	ActionExportCSVFile = new KAction(i18n("Export CSV File..."), "filexport", 0, this, SLOT(exportCSVFile()), actionCollection(), "export_csv_file");
    994. 

  994. 	ActionStoreResult = new KAction(i18n("Store Result..."), "filesave", CTRL+Key_S, this, SLOT(storeResult()), actionCollection(), "store_result");
    995. 

  995. 	ActionSaveAsImage = new KAction(i18n("Save Result Image..."), "filesave", 0, this, SLOT(saveAsImage()), actionCollection(), "save_as_image");
    996. 

  996. 	ActionSaveDefinitions = new KAction(i18n("Save Definitions"), "filesave", 0, this, SLOT(saveDefinitions()), actionCollection(), "save_definitions");
    997. 

  997. 	ActionUpdateExchangeRates = new KAction(i18n("Update Exchange Rates"), "reload", 0, this, SLOT(updateExchangeRates()), actionCollection(), "update_exchange_rates");
    998. 

  998. 	ActionPlotFunctionsData = new KAction(i18n("Plot Functions/Data"), 0, this, SLOT(plotFunctionsData()), actionCollection(), "plot_functions_data");
    999. 

  999. 	ActionPlotFunctionsData->setEnabled(canplot);
    1000. 

  1000. 	ActionConvertNumberBases = new KAction(i18n("Convert Number Bases"), 0, this, SLOT(convertNumberBases()), actionCollection(), "convert_number_bases");
    1001. 

  1001. 	ActionPeriodicTable = new KAction(i18n("Periodic Table"), 0, this, SLOT(periodicTable()), actionCollection(), "periodic_table");
    1002. 

  1002. 	if(close_to_systray) {
    1003. 

  1003. 		ActionClose = KStdAction::close(this, SLOT(close()), actionCollection());
    1004. 

  1004. 	} else {
    1005. 

  1005. 		ActionClose = NULL;
    1006. 

  1006. 	}
    1007. 

  1007. 	globalAccel = new KGlobalAccel(this);
    1008. 

  1008. 	globalAccel->insert("Show/hide Qalculate!", i18n("Show/hide main Qalculate! window"), QString::null, KShortcut(), KShortcut(), this, SLOT(showHide()));
    1009. 

  1009. 	globalAccel->readSettings();
    1010. 

  1010. 	globalAccel->updateConnections();
    1011. 

  1011. 	ActionConfigureGlobalShortcuts = new KAction(i18n("Configure &Global Shortcuts..."), "configure_shortcuts", 0, this, SLOT(configureGlobalShortcuts()), actionCollection(), "configure_global_shortcuts");
    1012. 

  1012. 	ActionQuit = KStdAction::quit(qApp, SLOT(quit()), actionCollection());
    1013. 

  1013. 	ActionManageVariables = new KAction(i18n("Manage Variables"), Key_F2, this, SLOT(manageVariables()), actionCollection(), "manage_variables");
    1014. 

  1014. 	ActionManageFunctions = new KAction(i18n("Manage Functions"), Key_F3, this, SLOT(manageFunctions()), actionCollection(), "manage_functions");
    1015. 

  1015. 	ActionManageUnits = new KAction(i18n("Manage Units"), Key_F4, this, SLOT(manageUnits()), actionCollection(), "manage_units");
    1016. 

  1016. 	ActionManageDataSets = new KAction(i18n("Manage Data Sets"), 0, this, SLOT(manageDataSets()), actionCollection(), "manage_data_sets");
    1017. 

  1017. 	ActionFactorize = new KAction(i18n("Factorize"), 0, this, SLOT(factorize()), actionCollection(), "factorize");
    1018. 

  1018. 	ActionSimplify = new KAction(i18n("Simplify"), 0, this, SLOT(simplify()), actionCollection(), "simplify");
    1019. 

  1019. 	ActionSetUnknowns = new KAction(i18n("Set Unknowns..."), 0, this, SLOT(setUnknowns()), actionCollection(), "set_unknowns");
    1020. 

  1020. 	ActionConvertToUnitExpression = new KAction(i18n("Convert to Unit Expression..."), CTRL+Key_T, this, SLOT(convertToUnitExpression()), actionCollection(), "convert_to_unit_expression");
    1021. 

  1021. 	ActionConvertToBaseUnits = new KAction(i18n("Convert to Base Units"), 0, this, SLOT(convertToBaseUnits()), actionCollection(), "convert_to_base_units");
    1022. 

  1022. 	ActionConvertToBestUnit = new KAction(i18n("Convert to Best Unit"), 0, this, SLOT(convertToBestUnit()), actionCollection(), "convert_to_best_unit");
    1023. 

  1023. 	ActionInsertMatrix = new KAction(i18n("Insert Matrix..."), 0, this, SLOT(insertMatrix()), actionCollection(), "insert_matrix");
    1024. 

  1024. 	ActionInsertVector = new KAction(i18n("Insert Vector..."), 0, this, SLOT(insertVector()), actionCollection(), "insert_vector");
    1025. 

  1025. 	ActionCopyResult = new KAction(i18n("Copy Result"), "editcopy", Key_F5, this, SLOT(copyResult()), actionCollection(), "copy_result");
    1026. 

  1026. 	ActionClearHistory = new KAction(i18n("Clear History"), "editclear", 0, this, SLOT(clearHistory()), actionCollection(), "clear_history");	
    1027. 

  1027. 	ActionPreferences = new KAction(i18n("Configure Qalculate!"), "configure", 0, this, SLOT(preferences()), actionCollection(), "preferences");
    1028. 

  1028. 	KStdAction::keyBindings(guiFactory(), SLOT(configureShortcuts()), actionCollection(), "keybindings");
    1029. 

  1029. 	ActionNumberBaseBinary = new KRadioAction(i18n("Binary"), 0, this, SLOT(numberBaseBinary()), actionCollection(), "number_base_binary");
    1030. 

  1030. 	ActionNumberBaseBinary->setExclusiveGroup("group_number_base");
    1031. 

  1031. 	ActionNumberBaseOctal = new KRadioAction(i18n("Octal"), 0, this, SLOT(numberBaseOctal()), actionCollection(), "number_base_octal");
    1032. 

  1032. 	ActionNumberBaseOctal->setExclusiveGroup("group_number_base");
    1033. 

  1033. 	ActionNumberBaseDecimal = new KRadioAction(i18n("Decimal"), 0, this, SLOT(numberBaseDecimal()), actionCollection(), "number_base_decimal");
    1034. 

  1034. 	ActionNumberBaseDecimal->setExclusiveGroup("group_number_base");
    1035. 

  1035. 	ActionNumberBaseHexadecimal = new KRadioAction(i18n("Hexadecimal"), 0, this, SLOT(numberBaseHexadecimal()), actionCollection(), "number_base_hexadecimal");
    1036. 

  1036. 	ActionNumberBaseHexadecimal->setExclusiveGroup("group_number_base");
    1037. 

  1037. 	ActionNumberBaseOther = new KRadioAction(i18n("Other..."), 0, this, SLOT(numberBaseOther()), actionCollection(), "number_base_other");
    1038. 

  1038. 	ActionNumberBaseOther->setExclusiveGroup("group_number_base");
    1039. 

  1039. 	ActionNumberBaseSexagesimal = new KRadioAction(i18n("Sexagesimal"), 0, this, SLOT(numberBaseSexagesimal()), actionCollection(), "number_base_sexagesimal");
    1040. 

  1040. 	ActionNumberBaseSexagesimal->setExclusiveGroup("group_number_base");
    1041. 

  1041. 	ActionNumberBaseTimeFormat = new KRadioAction(i18n("Time Format"), 0, this, SLOT(numberBaseTimeFormat()), actionCollection(), "number_base_time_format");
    1042. 

  1042. 	ActionNumberBaseTimeFormat->setExclusiveGroup("group_number_base");
    1043. 

  1043. 	ActionNumberBaseRomanNumerals = new KRadioAction(i18n("Roman Numerals"), 0, this, SLOT(numberBaseRomanNumerals()), actionCollection(), "number_base_roman_numerals");
    1044. 

  1044. 	ActionNumberBaseRomanNumerals->setExclusiveGroup("group_number_base");
    1045. 

  1045. 	ActionSetBase = new KAction(i18n("Select Result and Expression Base..."), CTRL+Key_B, this, SLOT(setBase()), actionCollection(), "set_base");
    1046. 

  1046. 	ActionNumericalDisplayNormal = new KRadioAction(i18n("Normal"), 0, this, SLOT(numericalDisplayNormal()), actionCollection(), "numerical_display_normal");
    1047. 

  1047. 	ActionNumericalDisplayNormal->setExclusiveGroup("group_numberical_display");
    1048. 

  1048. 	ActionNumericalDisplayEngineering = new KRadioAction(i18n("Engineering"), 0, this, SLOT(numericalDisplayEngineering()), actionCollection(), "numerical_display_engineering");
    1049. 

  1049. 	ActionNumericalDisplayEngineering->setExclusiveGroup("group_numberical_display");
    1050. 

  1050. 	ActionNumericalDisplayScientific = new KRadioAction(i18n("Scientific"), 0, this, SLOT(numericalDisplayScientific()), actionCollection(), "numerical_display_scientific");
    1051. 

  1051. 	ActionNumericalDisplayScientific->setExclusiveGroup("group_numberical_display");
    1052. 

  1052. 	ActionNumericalDisplayPurelyScientific = new KRadioAction(i18n("Purely Scientific"), 0, this, SLOT(numericalDisplayPurelyScientific()), actionCollection(), "numerical_display_purely_scientific");
    1053. 

  1053. 	ActionNumericalDisplayPurelyScientific->setExclusiveGroup("group_numberical_display");
    1054. 

  1054. 	ActionNumericalDisplaySimple = new KRadioAction(i18n("Simple"), 0, this, SLOT(numericalDisplaySimple()), actionCollection(), "numerical_display_simple");
    1055. 

  1055. 	ActionNumericalDisplaySimple->setExclusiveGroup("group_numberical_display");
    1056. 

  1056. 	ActionIndicateInfiniteSeries = new KToggleAction(i18n("Indicate Infinite Series"), 0, actionCollection(), "indicate_infinite_series");
    1057. 

  1057. 	QObject::connect(ActionIndicateInfiniteSeries, SIGNAL(toggled(bool)), this, SLOT(indicateInfiniteSeries(bool)));
    1058. 

  1058. 	ActionSortMinusLast = new KToggleAction(i18n("Sort Minus Last"), 0, actionCollection(), "sort_minus_last");
    1059. 

  1059. 	QObject::connect(ActionSortMinusLast, SIGNAL(toggled(bool)), this, SLOT(sortMinusLast(bool)));
    1060. 

  1060. 	ActionNegativeExponents = new KToggleAction(i18n("Negative Exponents"), 0, actionCollection(), "negative_exponents");
    1061. 

  1061. 	QObject::connect(ActionNegativeExponents, SIGNAL(tog…
    1062.

Large files files are truncated, but you can click here to view the full file