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.
knutclient/src/knutdock.cpp

995 lines
30 KiB

/***************************************************************************
knutdock.cpp - description
-------------------
begin : <EFBFBD>t zari 23 2003
copyright : (C) 2003 by Daniel Prynych
email : Daniel.Prynych@alo.cz
***************************************************************************/
/***************************************************************************
* *
* 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. *
* *
***************************************************************************/
#include "knutdock.h"
#include "knutnet.h"
//#include <tdeglobal.h>
#include <kiconloader.h>
#include <tdelocale.h>
#include <kapp.h>
#include <tdeaboutapplication.h>
#include <tdemessagebox.h>
#include <tqpainter.h>
#include <tqtooltip.h>
#include <tqpixmap.h>
#include <tqbitmap.h>
#include <tqstring.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//#include <iostream>
//#define ICON_SIZE 24
#define ICON_SIZE 22
KNutDock::KNutDock(KNutVarData::upsInfoDef* activeUpsInfo, KNutVarData::SettingDataDef* settingData, KNutUpsData* upsRecords){
TQString valueName;
m_settingData = settingData;
m_upsRecords = upsRecords;
m_activeUpsInfo = activeUpsInfo;
//saves backgroundcolor of kicker
backgroundColor = paletteBackgroundColor();
m_typeOfIcon = m_settingData->typeOfTDEIcon;
if (!m_settingData->customTDEIconColor) m_myBGColor = backgroundColor;
else m_myBGColor = m_settingData->kIconBackgroundColor;
m_toolTipFlags=m_settingData->toolTipFlags;
clearValues();
TDEIconLoader *loader = TDEGlobal::iconLoader();
m_mainPix = loader->loadIcon ("knutclient",TDEIcon::Small,16);
// aplications's own icons
m_errorPix = UserIcon ("knc_error");
m_connectPix = UserIcon ("knc_conn");
m_upsPix = UserIcon ("knc_ups");
m_battPix = UserIcon ("knc_batt");
createMainMenu();
#define ICON_SIZE 22
m_statusLayer = 0;
m_runtimeLayer = 0;
m_loadLayer = new TQPixmap(ICON_SIZE,ICON_SIZE);
m_chargeLayer = new TQPixmap(ICON_SIZE,ICON_SIZE);
m_mainLayer = new TQPixmap(ICON_SIZE,ICON_SIZE);
initImage();
changeTDEIcon(); // this function calls function repaintIcon
}
KNutDock::~KNutDock(){
if (m_statusLayer) delete m_statusLayer;
if (m_runtimeLayer) delete m_runtimeLayer;
delete m_loadLayer;
delete m_chargeLayer;
delete m_mainLayer;
delete m_upsServerMenu;
delete m_menu;
}
void KNutDock::resizeEvent ( TQResizeEvent * ){
initImage();
changeTDEIcon(); // this function calls function repaintIcon
}
void KNutDock::changeUps (void) {
m_upsServerMenu->clear();
createUpsMenu();
}
void KNutDock::clearDockValues(void){
initImage(); // paints standart icon
clearValues();
repaintDock(true);
}
void KNutDock::changeToolTip(void){
m_toolTipFlags=m_settingData->toolTipFlags;
toolTip(m_runtimeValue, m_statusValue, m_batteryChargeValue, m_upsLoadValue);
}
void KNutDock::changeKIBColor(void) {
if (!m_settingData->customTDEIconColor) m_myBGColor = backgroundColor;
else m_myBGColor = m_settingData->kIconBackgroundColor; // uses defined color
repaintDock(true);
}
void KNutDock::changeTDEIcon (void) {
m_typeOfIcon = m_settingData->typeOfTDEIcon;
if ( m_typeOfIcon == generalKI) {
if (m_mainLayer) {
delete m_mainLayer;
m_mainLayer=new TQPixmap(ICON_SIZE,ICON_SIZE);
}
if (!m_statusLayer) {
m_statusLayer = new TQPixmap(ICON_SIZE,ICON_SIZE);
}
if (!m_runtimeLayer) {
m_runtimeLayer = new TQPixmap(ICON_SIZE,ICON_SIZE);
}
paintStatus(m_statusValue);
paintRuntime(m_runtimeValue, m_statusValue);
}
else { // picture Icon
delete m_statusLayer;
m_statusLayer = 0;
delete m_runtimeLayer;
m_runtimeLayer=0;
}
paintLoad(m_upsLoadValue);
paintCharge(m_batteryChargeValue);
m_statusWarningValue = m_statusValue & (KNutNet::CAL | KNutNet::TRIM | KNutNet::BOOST
| KNutNet::OVER | KNutNet::RB);
repaintDock(true);
}
void KNutDock::initImage(void) {
setPixmap(m_mainPix);
m_dataOk = idle;
m_dataOkOld = m_dataOk;
}
void KNutDock::setNewUPS(void) {
m_upsServerMenu->clear();
createUpsMenu();
}
void KNutDock::repaintDock (const bool always) {
TQString nutStringVar;
int myRuntimeValue;
int myUpsLoadValue;
int myStatusValue;
int myStatusBatValue;
int myBatteryChargeValue;
bool repaintNow = false;
// value repaintNow is seted when some ups values are changed
bool okFloat;
TQString valueName;
TQPainter paint;
if (m_activeUpsInfo->upsNet == 0) { repaint(); return;}
m_dataOkOld=m_dataOk;
if ((m_activeUpsInfo->upsNet->getState() == KNutNet::Connected) // paints icons with information values
&& (!m_activeUpsInfo->netError)) {
// ups is connected dataOK is ok (program shows icon of connecting UPS)
m_dataOk = ok; // pro paint event udava ze mam pouzit nase ikony
if (!m_activeUpsInfo->upsNet->existName(m_activeUpsInfo->runtimeVar)) {
nutStringVar = m_activeUpsInfo->upsNet->readStringVar(m_activeUpsInfo->runtimeVar);
//std::cout << "KNutDock::repaintDock RUNTIME " << nutStringVar << std::endl;
if (nutStringVar.isEmpty()) myRuntimeValue=knc::numberVarError;
else {
myRuntimeValue = (int)nutStringVar.toFloat(&okFloat);
if (!okFloat) myRuntimeValue = knc::numberVarError;
}
}
else myRuntimeValue = knc::numberVarError;
myStatusValue = m_activeUpsInfo->upsNet->readStatus();
switch (m_typeOfIcon) {
case generalKI:
// *********STATUS****************
if (myStatusValue !=m_statusValue ) {
m_statusValue = myStatusValue;
paintStatus(m_statusValue);
repaintNow = true;
}
// **********RUNTIME***********
myStatusBatValue = myStatusValue & KNutNet::OB; // OB = UPS runs on battery
if ((myRuntimeValue != m_runtimeValue) || (myStatusBatValue != m_statusBatValue)) {
// when runtime is changed or flags OB is changed we must repaint icons
// when OB is changed same items in icon will change color
m_runtimeValue = myRuntimeValue; // runtime is old value of runtime, one is defined like global value of class
m_statusBatValue = myStatusBatValue;
paintRuntime(m_runtimeValue, m_statusValue);
repaintNow = true;
}
break;
case pictureKI:
// *********STATUS****************
if (myStatusValue !=m_statusValue ) {
m_statusValue = myStatusValue;
m_statusWarningValue = myStatusValue & (KNutNet::CAL | KNutNet::TRIM | KNutNet::BOOST
| KNutNet::OVER | KNutNet::RB);
repaintNow = true;
}
// **********RUNTIME***********
if (myRuntimeValue != m_runtimeValue) {
m_runtimeValue = myRuntimeValue;
repaintNow = true;
}
break;
} ///////////////////// end of models
// Other values are for all modes
// **********UPS LOAD***************
if (m_activeUpsInfo->nutVariables == 1) valueName = "LOADPCT";
else valueName = "ups.load";
if (!m_activeUpsInfo->upsNet->existName(valueName)) {
nutStringVar = m_activeUpsInfo->upsNet->readStringVar(valueName);
if (nutStringVar.isEmpty()) myUpsLoadValue=knc::numberVarError;
else {
myUpsLoadValue = (int)nutStringVar.toFloat(&okFloat);
if (!okFloat) myUpsLoadValue=knc::numberVarError;
}
}
else myUpsLoadValue=knc::numberVarError;
if (myUpsLoadValue != m_upsLoadValue) {
m_upsLoadValue = myUpsLoadValue;
if (m_typeOfIcon == generalKI) paintLoad(m_upsLoadValue);
repaintNow = true;
}
// *********BATTERY CHARGE****************
if (m_activeUpsInfo->nutVariables == 1) valueName="BATTPCT";
else valueName="battery.charge";
if (!m_activeUpsInfo->upsNet->existName(valueName)) {
nutStringVar = m_activeUpsInfo->upsNet->readStringVar(valueName);
if (nutStringVar.isEmpty()) myBatteryChargeValue=knc::numberVarError;
else {
myBatteryChargeValue = (int)nutStringVar.toFloat(&okFloat);
if (!okFloat) myBatteryChargeValue = knc::numberVarError;
}
}
else myBatteryChargeValue=knc::numberVarError;
if (myBatteryChargeValue != m_batteryChargeValue) {
m_batteryChargeValue = myBatteryChargeValue;
if (m_typeOfIcon == generalKI)paintCharge(m_batteryChargeValue);
repaintNow = true;
}
// ************* End of values********************
if (repaintNow || always || (m_dataOk != m_dataOkOld)) {
switch (m_typeOfIcon) {
case generalKI:
m_mainLayer->fill(m_myBGColor);
// copyBlt (m_mainLayer,0,0,m_runtimeLayer,0,0,ICON_SIZE,ICON_SIZE);
bitBlt (m_mainLayer,0,0,m_runtimeLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP);
bitBlt (m_mainLayer,0,0,m_loadLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP);
bitBlt (m_mainLayer,0,0,m_chargeLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP);
bitBlt (m_mainLayer,0,0,m_statusLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP);
break;
case pictureKI:
// if (m_statusValue & KNutNet::OL) bitBlt (m_mainLayer,0,0,m_loadLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP); // icon of UPS
if (m_statusValue & KNutNet::OL) { // ONLINE - icon of UPS
int myLoad;
TQPainter paint;
copyBlt (m_mainLayer,0,0,&m_upsPix,0,0,ICON_SIZE,ICON_SIZE); // icon of UPS
paint.begin(m_mainLayer);
if (m_upsLoadValue == knc::numberVarError) myLoad=0;
else myLoad = abs(m_upsLoadValue/10);
if (m_upsLoadValue != knc::numberVarError) {
if (myLoad > 12) myLoad=12;
if (myLoad > 10) myLoad++; // preskocime rysku pro 100 %
if (myLoad < 9) paint.setPen(TQColor(0,192,0)); //green
else {
if (myLoad < 11) paint.setPen(TQColor(255,255,0)); //yellow
else paint.setPen(TQColor(255,0,0));//red
}
for (int i = 19; i < 22; i++) paint.drawLine(i,13,i,13-myLoad +1);
if (myLoad < 13) {
paint.setPen(TQColor(168,220,255));
for (int i = 20; i < 23; i++ ) paint.drawLine(i,1,i,13-myLoad);
}
}
paint.setPen(TQColor(TQt::black)); // line for 100 % load
paint.drawLine(19,3,22,3);
if (!m_statusWarningValue) paintOKPoint(paint);
else paintErrorPoint(paint);
paint.end();
}
else {
TQPainter paint;
copyBlt (m_mainLayer,0,0,&m_battPix,0,0,ICON_SIZE,ICON_SIZE); // icon of Battery
paint.begin(m_mainLayer);
if (m_batteryChargeValue != knc::numberVarError) {
if (m_batteryChargeValue < 40) paint.setPen(TQt::red);
else paint.setPen(TQt::black);
if (m_batteryChargeValue < 40) paint.setPen(TQt::red);
else {
if (m_batteryChargeValue < 50) paint.setPen(TQt::yellow);
else paint.setPen(TQt::green);
}
int delka = abs((16*m_batteryChargeValue)/100);
delka += abs((delka-1)/4) -1;
paint.drawLine (2,7,2+delka,7);
paint.drawLine (2,8,2+delka,8);
paint.drawLine (2,9,2+delka,9);
}
paint.end();
}
break;
}
toolTip(m_runtimeValue, m_statusValue, m_batteryChargeValue, m_upsLoadValue);
setPixmap(*m_mainLayer);
}
}
else { // KNutNet->state isn't connected
// we must test activeUpsInfo->netError because error can rise higher level
if (m_activeUpsInfo->netError)
m_dataOk = error; // error is value not variable
else {
if ((m_activeUpsInfo->upsNet->getState() == KNutNet::Connecting) ||
(m_activeUpsInfo->upsNet->getState() == KNutNet::HostLookup))
m_dataOk = connecting;
else m_dataOk = idle;
}
if ((m_dataOk != m_dataOkOld) or always) {
toolTip(0, -1, 0, 0);
m_dataOkOld=m_dataOk;
if (m_dataOk == connecting) setPixmap(m_connectPix);
else {
if (m_dataOk == error) setPixmap(m_errorPix);
else {
setPixmap(m_mainPix);
}
}
}
}
repaint();
}
void KNutDock::toolTip (int runtime, int status, int batteryCharge, int upsLoad ) {
TQString text;
TQString manufacturer = "";
TQString upsModel = "";
TQString serial = "";
TQString firmware = "";
int myNetErr = 0;
int min = abs(runtime/60);
int sec = runtime - (min*60);
if (m_activeUpsInfo->upsNet != 0) {
myNetErr= m_activeUpsInfo->upsNet->getError();
switch (m_activeUpsInfo->nutVariables) {
case 1:
manufacturer = m_activeUpsInfo->upsNet->readStringVar("MFR");
upsModel = m_activeUpsInfo->upsNet->readStringVar("MODEL");
serial = m_activeUpsInfo->upsNet->readStringVar("SERIAL");
firmware = m_activeUpsInfo->upsNet->readStringVar("FIRMREV");
break;
case 2:
manufacturer = m_activeUpsInfo->upsNet->readStringVar("ups.mfr");
upsModel = m_activeUpsInfo->upsNet->readStringVar("ups.model");
serial = m_activeUpsInfo->upsNet->readStringVar("ups.serial");
firmware = m_activeUpsInfo->upsNet->readStringVar("ups.firmware");
break;
}
}
text = i18n("Name")+" : "+m_activeUpsInfo->record.name + "\n"
+i18n("UPS name")+" : "+m_activeUpsInfo->record.upsName + "\n"
+i18n("UPS address")+" : "+m_activeUpsInfo->record.upsAddress +"\n"
+i18n("Status : ");
if (status == -1) {
text += i18n("Connection doesn't exist.");
}
else {
if (status & KNutNet::OL) {
text += i18n("UPS On line");
}
else {
if (status & KNutNet::OB) {
text += i18n("UPS On battery");
}
else {
if (status & KNutNet::OFF) {
text += i18n("UPS Of line");
}
}
}
if (status & KNutNet::LB) {
text += "\n" + i18n("Status : ") + i18n("UPS Battery is low");
}
if (status & KNutNet::RB) {
text += "\n" + i18n("Status : ") + i18n("Replace battery");
}
if (status & KNutNet::CAL) {
text += "\n" + i18n("Status : ") + i18n("UPS is performing calibration");
}
if (status & KNutNet::OVER) {
text += "\n" + i18n("Status : ") + i18n("UPS is Overload");
}
if (status & KNutNet::TRIM) {
text += "\n" + i18n("Status : ") + i18n("UPS is trimming voltage");
}
if (status & KNutNet::BOOST) {
text += "\n" + i18n("Status : ")+ i18n("UPS is boosting voltage");
}
}
if ((status == -1) && (myNetErr != KNutNet::NoError)) {
text += "\n" + i18n("Error : ")+ KNutVarData::errorToText(myNetErr);
}
if (m_toolTipFlags & TTMFR) text += "\n" + i18n("Manufac. : ")+ manufacturer;
if (m_toolTipFlags & TTModel) text += "\n" + i18n("Name")+" : "+ upsModel;
if (m_toolTipFlags & TTSerial) text += "\n" + i18n("Serial")+" : "+ serial;
if (m_toolTipFlags & TTFirm) text += "\n" + i18n("Firmware")+" : "+ firmware;
if (m_toolTipFlags & TTRun) {
if (runtime != knc::numberVarError)
text += "\n" + i18n("Runtime") + i18n(" : %1:%2 min").arg(min).arg(sec);
}
if (m_toolTipFlags & TTCharge) {
if (batteryCharge != knc::numberVarError)
text += "\n" + i18n("Battery Charge") + TQString(" : %1 %").arg(batteryCharge);
}
if (m_toolTipFlags & TTLoad) {
if (upsLoad != knc::numberVarError)
text += "\n" + i18n("UPS Load") + TQString(" : %1 %").arg(upsLoad);
}
TQToolTip::remove(this);
TQToolTip::add(this,text);
}
/*********************************************************************************************/
/* */
/* PRIVATE SLOTS */
/* */
/*********************************************************************************************/
void KNutDock::slotShowMyAbout() {
TDEAboutApplication *dialog;
dialog= new TDEAboutApplication;
dialog->exec();
delete dialog;
}
void KNutDock::slotExitApplication (void) {
if (m_settingData->areYouSure) {
if (KMessageBox::warningYesNo (0,i18n("Are you sure ?")) == 3)
emit endApplication();
}
else emit endApplication();
}
void KNutDock::slotUpsName(int i) {
emit UPSChanged(m_upsRecords->getName(i-101));
}
void KNutDock::slotMinimize(void) {
emit minimize ();
}
void KNutDock::slotPreferences(void) {
emit preferences();
}
void KNutDock::slotPrintUPSVars(void) {
emit printUPSVars();
}
void KNutDock::slotInstComms(void) {
emit instComms();
}
void KNutDock::slotRWVars(void) {
emit RWVars();
}
void KNutDock::slotRefreshConnection(void) {
emit makeRefreshConnection();
}
//------------------------------------------
void KNutDock::mousePressEvent(TQMouseEvent *e) {
//tqDebug("KNutDock::mousePressEvent");
if( e->button()==Qt::LeftButton ) emit activeMainWindow();
if( e->button()==Qt::RightButton ) m_menu->popup(e->globalPos());
}
void KNutDock::paintEvent (TQPaintEvent *e) {
KSystemTray::paintEvent(e);
if ((m_activeUpsInfo->upsNet->getState() == KNutNet::Connected) and
(m_statusValue != KNutNet::NS)) { // When driver isn't connected, getState is connected and m_statusValue is NS // NONE STATUS
if (m_typeOfIcon == pictureKI) {
TQPainter painter(this);
// painter.begin();
if (m_statusValue & KNutNet::OL) { // ONLINE - icon of UPS
painter.setPen(TQt::black);
paintNumbers (m_upsLoadValue, (width()/-11), ((float) width()/(float) 1.46666666667), &painter, ((float) width()/(float) 22) );
}
else { // OFFLINE icon of battery
if (m_batteryChargeValue != knc::numberVarError) {
if (m_batteryChargeValue < 40) painter.setPen(TQt::red);
else painter.setPen(TQt::black);
paintNumbers(m_batteryChargeValue,(width()/-11),((float) width()/(float) 1.375),&painter, ((float) width()/(float) 22));
}
else {
painter.setPen(TQt::black);
paintDash (((float) width()/(float) 7.33333333333),((float) width()/(float) 1.375),&painter, ((float) width()/(float) 22));
paintDash (((float) width()/(float) 2.75),((float) width()/(float) 1.375),&painter, ((float) width()/(float) 22));
}
}
// painter.end();
}
}
}
/*********************************************************************************************/
/* */
/* PRIVATE FUNCTIONS */
/* */
/*********************************************************************************************/
void KNutDock::clearValues(void) {
m_batteryChargeValue = 0;
m_runtimeValue = 0;
m_upsLoadValue = 0;
m_statusValue = 0;
}
void KNutDock::createUpsMenu(void) {
int n = m_upsRecords->getCount();
for (int i =0; i < n; i++) {
if (m_activeUpsInfo->record.name == m_upsRecords->getName(i))
m_upsServerMenu->insertItem(kapp->miniIcon(),m_upsRecords->getName(i), this, TQT_SLOT(slotUpsName(int)),0,101+i);
else
m_upsServerMenu->insertItem(m_upsRecords->getName(i), this, TQT_SLOT(slotUpsName(int)),0,101+i);
}
}
void KNutDock::createMainMenu(void) {
m_menu = new TDEPopupMenu;
m_upsServerMenu = new TDEPopupMenu;
createUpsMenu();
m_menu->insertTitle (kapp->miniIcon(),"knutclient");
m_menu->insertSeparator();
m_menu->insertItem("UPS",m_upsServerMenu);
m_menu->insertSeparator();
m_menu->insertItem(i18n("&Showing UPS variables and commands"), this, TQT_SLOT(slotPrintUPSVars()));
m_menu->insertItem(i18n("&Running instant commands"), this, TQT_SLOT(slotInstComms()));
m_menu->insertItem(i18n("Setting R&W variables"), this, TQT_SLOT(slotRWVars()));
m_menu->insertSeparator();
m_menu->insertItem(SmallIcon("reload"),i18n("Reconnect"), this, TQT_SLOT(slotRefreshConnection()));
m_menu->insertSeparator();
m_menu->insertItem(SmallIcon("configure"),i18n("&Preferences"), this, TQT_SLOT(slotPreferences()));
m_menu->insertSeparator();
m_menu->insertItem(kapp->miniIcon(),i18n("&About KNutClient"), this, TQT_SLOT(slotShowMyAbout()));
m_menu->insertSeparator();
m_menu->insertItem(i18n("&Minimize"), this, TQT_SLOT(slotMinimize()));
m_menu->insertSeparator();
m_menu->insertItem (SmallIcon("system-log-out"),i18n("&Exit"),this ,TQT_SLOT(slotExitApplication()));
}
void KNutDock::paintCharge (int charge ) {
TQPainter paint;
m_chargeLayer->fill(TQt::white);
paint.begin(m_chargeLayer);
if (charge > 199) charge = 199;
if (m_typeOfIcon == generalKI) {
if (charge != knc::numberVarError) {
if (charge < 40) paint.setPen(TQt::red);
else paint.setPen(TQt::black);
paintNumbers(charge,8,2,&paint, 1);
}
else {
paint.setPen(TQt::black);
paintDash (13,2,&paint, 1);
paintDash (18,2,&paint, 1);
}
}
else {
// picture version
if (charge != knc::numberVarError) {
if (charge < 40) paint.setPen(TQt::red);
else paint.setPen(TQt::black);
paintNumbers(charge,-2,16,&paint, 1);
if (charge < 40) paint.setPen(TQt::red);
else {
if (charge < 50) paint.setPen(TQt::yellow);
else paint.setPen(TQt::green);
}
int delka = abs((16*charge)/100);
delka += abs((delka-1)/4) -1;
paint.drawLine (2,7,2+delka,7);
paint.drawLine (2,8,2+delka,8);
paint.drawLine (2,9,2+delka,9);
}
else {
paint.setPen(TQt::black);
paintDash (3,16,&paint, 1);
paintDash (8,16,&paint, 1);
}
}
paint.end();
}
void KNutDock::paintErrorPoint ( TQPainter& paint ) {
paint.setPen(TQColor(0,0,255));
paint.setPen(TQColor(255,0,0));
paint.drawLine(19,18,21,18);
paint.drawLine(19,19,21,19);
paint.drawLine(19,20,21,20);
}
void KNutDock::paintOKPoint (TQPainter& paint ) {
paint.setPen(TQColor(0,255,0));
paint.drawLine(19,18,21,18);
paint.drawLine(19,19,21,19);
paint.drawLine(19,20,21,20);
}
void KNutDock::paintStatus (int status ) {
TQPainter paint;
int lastPos = 0;
m_statusLayer->fill(TQt::white);
paint.begin(m_statusLayer);
if (status & KNutNet::OL) {
paint.setPen(TQt::black);
paintChar (1,2,'P',&paint);
}
else {
if (status & KNutNet::OB) {
paint.setPen(TQt::red);
paintChar (1,2,'B',&paint);
}
}
if (status & KNutNet::LB) {
paint.setPen(TQt::red);
paintChar (6,2,'L',&paint);
}
if ((lastPos <2) && (status & KNutNet::RB)) {
paint.setPen(TQt::red);
paintChar (6,2,'R',&paint);
lastPos++;
}
if ((lastPos <2) && (status & KNutNet::BOOST)) {
paint.setPen(TQt::red);
paintChar (6,2,'B',&paint);
lastPos++;
}
if ((lastPos <2) && (status & KNutNet::TRIM)) {
paint.setPen(TQt::red);
paintChar (6,2,'T',&paint);
lastPos++;
}
if ((lastPos <2) && (status & KNutNet::CAL)) {
paint.setPen(TQt::red);
paintChar (6,2,'C',&paint);
lastPos++;
}
paint.end();
}
void KNutDock::paintRuntime (int runtime, int status ) {
TQPainter paint;
m_runtimeLayer->fill(TQt::white);
paint.begin(m_runtimeLayer);
if (status & KNutNet::OB)
paint.setPen(TQt::red);
else
paint.setPen(TQt::black);
if (runtime != knc::numberVarError) {
int min = abs(runtime/60);
int sec = runtime - (min*60);
paintNumber(1,11, abs(min/10) ,&paint, 1);
paintNumber(6,11,min-((abs(min/10))*10) ,&paint, 1);
paintNumber(13,11, abs(sec/10) ,&paint, 1);
paintNumber(18,11,sec-((abs(sec/10))*10) ,&paint, 1);
}
else {
paintDash (1,11,&paint, 1);
paintDash (6,11,&paint, 1);
paintDash (13,11,&paint, 1);
paintDash (18,11,&paint, 1);
}
paint.drawLine (11,12,11,13);
paint.drawLine (11,15,11,16);
paint.end();
}
void KNutDock::paintLoad (int load ) {
TQPainter paint;
int myLoad;
// if (m_typeOfIcon != generalKI) bitBlt (m_loadLayer,0,0,m_upsLayer,0,0,ICON_SIZE,ICON_SIZE,AndROP);
m_loadLayer->fill(TQt::white);
paint.begin(m_loadLayer);
if (load == knc::numberVarError) myLoad=0;
else myLoad = abs(load/10);
if (m_typeOfIcon == generalKI) {
if (load != knc::numberVarError) {
if (myLoad > 11) myLoad=11;
if (myLoad < 9) paint.setPen(TQt::green);
else {
if (myLoad < 11) paint.setPen(TQt::yellow);
else paint.setPen(TQt::red);
}
paint.setPen(TQt::green.light(60));
for (int i = 0; i < myLoad; i++) {
paint.drawLine((i*2)+1,19,(i*2)+1,21);
}
paint.setPen(TQt::cyan.light(150));
for (int i = myLoad; i < 11; i++) {
paint.drawLine((i*2)+1,19,(i*2)+1,21);
}
}
}
paint.end();
}
void KNutDock::paintNumbers (int numbers, int x, int y, TQPainter* p, float sizeMult ) {
bool first = false;
if (numbers > 199) numbers = 199;
if (numbers != knc::numberVarError) {
if (numbers > 99) {
paintNumber (x,y,1,p,sizeMult);
numbers -= 100;
first=true;
}
int second = abs (numbers/10);
int third = numbers - (second * 10);
if ((second != 0) || (first)) paintNumber (((float) x+(5*sizeMult)),y,second,p,sizeMult);
paintNumber (((float) x+(10*sizeMult)),y,third,p,sizeMult);
}
else {
p->setPen(TQt::black);
paintDash (((float) x+(5*sizeMult)),y,p,sizeMult);
paintDash (((float) x+(10*sizeMult)),y,p,sizeMult);
}
}
void KNutDock::paintDash (int x, int y, TQPainter *p, float sizeMult) {
TQPen oldPen = p->pen();
TQPen newPen;
newPen.setWidth(((float) (oldPen.width()+1)*sizeMult)-1);
p->setPen(newPen);
p->drawLine(x,((float) y+(3*sizeMult)),((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
p->setPen(oldPen);
}
void KNutDock::paintNumber (int x, int y, int number, TQPainter *p, float sizeMult) {
// x and y are left top corner
TQPen oldPen = p->pen();
TQPen newPen;
newPen.setWidth(((float) (oldPen.width()+1)*sizeMult)-1);
p->setPen(newPen);
if ((number > -1) && (number < 10)) {
// painting - kreslim
switch (number) {
case 0:
p->drawRect(x,y,((float) 4*sizeMult),((float) 7*sizeMult));
break;
case 1:
p->drawLine (((float) x+(3*sizeMult)),y,((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
break;
case 2:
p->drawLine(x,y,((float) x+(3*sizeMult)),y);
p->lineTo(((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
p->lineTo(x,((float) y+(3*sizeMult)));
p->lineTo(x,((float) y+(6*sizeMult)));
p->lineTo(((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
break;
case 3:
p->drawLine(x,y,((float) x+(3*sizeMult)),y);
p->lineTo(((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
p->lineTo(x,((float) y+(6*sizeMult)));
p->drawLine(x,((float) y+(3*sizeMult)),((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
break;
case 4:
p->drawLine(x,y,x,((float) y+(3*sizeMult)));
p->lineTo(((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
p->drawLine (((float) x+(3*sizeMult)),y,((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
break;
case 5:
p->drawLine(((float) x+(3*sizeMult)),y,x,y);
p->lineTo(x,((float) y+(3*sizeMult)));
p->lineTo(((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
p->lineTo(((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
p->lineTo(x,((float) y+(6*sizeMult)));
break;
case 6:
p->drawRect(x,((float) y+(3*sizeMult)),((float) 4*sizeMult),((float) 4*sizeMult));
p->drawLine(x,((float) y+(3*sizeMult)),x,y);
p->lineTo(((float) x+(3*sizeMult)),y);
break;
case 7:
p->drawLine(x,y,((float) x+(3*sizeMult)),y);
p->lineTo(((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
break;
case 8:
p->drawRect(x,y,((float) 4*sizeMult),((float) 7*sizeMult));
p->drawLine(x,((float) y+(3*sizeMult)),((float) x+(3*sizeMult)),((float) y+(3*sizeMult)));
break;
case 9:
p->drawRect(x,y,((float) 4*sizeMult),((float) 4*sizeMult));
p->drawLine(((float) x+(3*sizeMult)),((float) y+(3*sizeMult)),((float) x+(3*sizeMult)),((float) y+(6*sizeMult)));
p->lineTo(x,((float) y+(6*sizeMult)));
break;
}
}
p->setPen(oldPen);
}
void KNutDock::paintChar (int x, int y, char LCDChar, TQPainter *p) {
// x and y are left up corner
switch (LCDChar) {
case 'L':
p->drawLine(x,y,x,y+6);
p->lineTo(x+3,y+6);
break;
case 'O':
p->drawRect(x,y,4,7);
break;
case 'B':
p->drawLine(x,y,x,y+6);
p->lineTo(x+2,y+6);
p->drawLine(x,y,x+2,y);
p->drawLine(x,y+3,x+2,y+3);
p->drawLine(x+3,y+1,x+3,y+2);
p->drawLine(x+3,y+4,x+3,y+5);
break;
case 'U':
p->drawLine(x,y,x,y+6);
p->lineTo(x+3,y+6);
p->lineTo(x+3,y);
break;
case 'C':
p->drawLine(x+3,y+1,x+3,y);
p->lineTo(x,y);
p->lineTo(x,y+6);
p->lineTo(x+3,y+6);
p->lineTo(x+3,y+5);
break;
case 'R':
p->drawLine(x,y,x,y+6);
p->drawLine(x,y,x+2,y);
p->drawLine(x,y+3,x+2,y+3);
p->drawLine(x+3,y+1,x+3,y+2);
p->drawLine(x+3,y+4,x+3,y+6);
break;
case 'P':
p->drawLine(x,y,x,y+6);
p->drawLine(x,y,x+2,y);
p->drawLine(x,y+3,x+2,y+3);
p->drawLine(x+3,y+1,x+3,y+2);
break;
case 'T':
p->drawLine(x+2,y,x+2,y+6);
p->drawLine(x,y,x+4,y);
break;
}
}
#include "knutdock.moc"