TDE
/
tdesdk
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdesdk
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3178453997'
${ noResults }
tdesdk/scheck/scheck.cpp

2788 lines
77 KiB
Raw Blame History Escape

/*
* $Id$
*
* KDE3 Style Guide compliance check "Style", v0.0.1
* Copyright (C) 2002 Maksim Orlovich <orlovich@cs.rochester.edu>
* (C) 2002 Ryan Cumming <ryan@completely.kicks-ass.org>
*
*
* Based on the KDE3 HighColor Style (version 1.0):
* Copyright (C) 2001-2002 Karol Szwed <gallium@kde.org>
* (C) 2001-2002 Fredrik H<>glund <fredrik@kde.org>
*
* Drawing routines adapted from the KDE2 HCStyle,
* Copyright (C) 2000 Daniel M. Duley <mosfet@kde.org>
* (C) 2000 Dirk Mueller <mueller@kde.org>
* (C) 2001 Martijn Klingens <klingens@kde.org>
*
* Portions of code are from the TQt GUI Toolkit, Copyright (C) 1992-2003 Trolltech AS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*
*/
#include <stdlib.h>
#include <tqdict.h>
#include <tqdrawutil.h>
#include <tqpainter.h>
#include <tqpointarray.h>
#include <tqstyleplugin.h>
#include <tqcheckbox.h>
#include <tqcombobox.h>
#include <tqfontmetrics.h>
#include <tqgroupbox.h>
#include <tqheader.h>
#include <tqlabel.h>
#include <tqmenubar.h>
#include <tqobjectlist.h>
#include <tqpushbutton.h>
#include <tqradiobutton.h>
#include <tqregexp.h>
#include <tqscrollbar.h>
#include <tqslider.h>
#include <tqstylesheet.h>
#include <tqtabbar.h>
#include <tqtimer.h>
#include <tqtoolbutton.h>
#include <tqtoolbar.h>
#include <tqpopupmenu.h>
#include <tqwidgetlist.h>
#include <kdrawutil.h>
#include <kaccelmanager.h>
#include <kpixmapeffect.h>
#include <kapplication.h>
#include <kaboutdata.h>
#include "scheck.h"
#include "scheck.moc"
#include "bitmaps.h"
// -- Style Plugin Interface -------------------------
class StyleCheckStylePlugin : public TQStylePlugin
{
public:
StyleCheckStylePlugin() {}
~StyleCheckStylePlugin() {}
TQStringList keys() const
{
return TQStringList() << "Check";
}
TQStyle* create( const TQString& key )
{
if ( key == "check" )
return new StyleCheckStyle( );
return 0;
}
};
KDE_Q_EXPORT_PLUGIN( StyleCheckStylePlugin )
// ---------------------------------------------------
// ### Remove globals
static TQBitmap lightBmp;
static TQBitmap grayBmp;
static TQBitmap dgrayBmp;
static TQBitmap centerBmp;
static TQBitmap maskBmp;
static TQBitmap xBmp;
static const int itemFrame = 1;
static const int itemHMargin = 3;
static const int itemVMargin = 0;
static const int arrowHMargin = 6;
static const int rightBorder = 12;
// ---------------------------------------------------------------------------
#include <tqvaluevector.h>
enum ColonMode
{
ColonlessWidget = 0,
BuddiedWidget = 1,
BuddylessWidget = 2
};
enum AccelMode
{
NoAccels = 0,
HasAccels = 1
};
enum TitleType
{
ShortTitle = 0,
LongTitle = 1
};
namespace
{
class StyleGuideViolation
{
private:
int m_position;
int m_severity; // 0 = error 1 = warning
public:
enum Severity
{
Error = 0,
Warning = 1,
AccelConflict = 2,
AccelSuggestion = 3,
Untranslated = 4
};
StyleGuideViolation() {}
StyleGuideViolation(int _position, int _severity = Error): m_position(_position), m_severity(_severity)
{}
operator int() const
{
return m_position;
}
int position() const
{
return m_position;
}
int severity() const
{
return m_severity;
}
};
class LowerCaseWords
{
private:
static TQDict<bool>* m_words;
public:
static TQDict<bool>* words()
{
if (!m_words)
{
m_words = new TQDict<bool>;
// Prepositions under five letters, except from & under
m_words->insert( "for", (bool*)1);
m_words->insert( "in", (bool*)1);
m_words->insert( "with", (bool*)1);
m_words->insert( "to", (bool*)1);
m_words->insert( "of", (bool*)1);
m_words->insert( "on", (bool*)1);
m_words->insert( "at", (bool*)1);
m_words->insert( "by", (bool*)1);
m_words->insert( "into", (bool*)1);
m_words->insert( "per", (bool*)1);
m_words->insert( "vs", (bool*)1);
// Conjunctions
m_words->insert( "and", (bool*)1);
m_words->insert( "or", (bool*)1);
m_words->insert( "nor", (bool*)1);
m_words->insert( "but", (bool*)1);
m_words->insert( "if", (bool*)1);
// Articles
m_words->insert( "the", (bool*)1);
m_words->insert( "a", (bool*)1);
m_words->insert( "as", (bool*)1);
m_words->insert( "an", (bool*)1);
// Misc
m_words->insert( "http", (bool*)1);
}
return m_words;
}
};
TQDict<bool>* LowerCaseWords::m_words = 0;
class ExplicitCaseWords
{
private:
static TQDict<const char>* m_words;
public:
static TQDict<const char>* words()
{
if (!m_words)
{
// Store the words like this:
// "lowercase", "CorrectCase"
m_words = new TQDict<const char>(61);
// week day names
m_words->insert( "monday", "Monday");
m_words->insert( "tuesday", "Tuesday");
m_words->insert( "wednesday", "Wednesday");
m_words->insert( "thursday", "Thursday");
m_words->insert( "friday", "Friday");
m_words->insert( "saturday", "Saturday");
m_words->insert( "sunday", "Sunday");
// month names
m_words->insert( "january", "January");
m_words->insert( "february", "February");
m_words->insert( "march", "March");
m_words->insert( "april", "April");
m_words->insert( "may", "May");
m_words->insert( "june", "June");
m_words->insert( "july", "July");
m_words->insert( "august", "August");
m_words->insert( "september", "September");
m_words->insert( "october", "October");
m_words->insert( "november", "November");
m_words->insert( "december", "December");
// displayed KDE names not matched by acronym algorithm
m_words->insert( "konqueror", "Konqueror");
m_words->insert( "kicker", "Kicker");
m_words->insert( "kopete", "Kopete");
m_words->insert( "kate", "Kate");
m_words->insert( "konsole", "Konsole");
m_words->insert( "kontour", "Kontour");
m_words->insert( "kiten", "Kiten");
m_words->insert( "kooka", "Kooka");
m_words->insert( "noatun", "Noatun");
// computer
m_words->insert( "ctrl", "Ctrl");
m_words->insert( "java", "Java");
m_words->insert( "javascript", "JavaScript");
m_words->insert( "qt", "TQt");
m_words->insert( "doxygen", "Doxygen");
m_words->insert( "linux", "Linux");
m_words->insert( "unix", "UNIX");
m_words->insert( "internet", "Internet");
m_words->insert( "web", "Web");
m_words->insert( "motif", "Motif");
m_words->insert( "x11", "X11");
m_words->insert( "socks", "SOCKS");
m_words->insert( "xing", "Xing");
m_words->insert( "yamaha", "Yamaha");
m_words->insert( "hz", "Hz");
m_words->insert( "khz", "KHz");
m_words->insert( "mhz", "MHz");
m_words->insert( "macos", "MacOS");
m_words->insert( "microsoft", "Microsoft");
m_words->insert( "adobe", "Adobe");
m_words->insert( "postscript", "PostScript");
m_words->insert( "ghostscript", "Ghostscript");
m_words->insert( "vcard", "vCard");
m_words->insert( "midi", "MIDI");
m_words->insert( "isdn", "ISDN");
m_words->insert( "cd-rom", "CD-ROM");
}
return m_words;
}
};
TQDict<const char>* ExplicitCaseWords::m_words = 0;
}
static bool xxMode;
static TQColor severityColor(int severity)
{
if (severity == StyleGuideViolation::Error)
{
return TQt::red;
}
else if (severity == StyleGuideViolation::AccelConflict)
{
return TQColor(255, 128, 0);
}
else if (severity == StyleGuideViolation::AccelSuggestion)
{
return TQt::green;
}
else if (severity == StyleGuideViolation::Untranslated)
{
return TQColor(255, 0, 255);
}
else
{
return TQt::yellow;
}
}
// Removes '&' style accelerators from text strings
static void removeAccelerators(TQString &str)
{
for (unsigned int p = 0; p < str.length(); p++)
{
if (str[p] == '&')
{
str = str.mid(0, p) + str.mid(p+1);
// Skip the next letter, as && mean a literal "&"
p++;
}
}
}
static void removeXX(TQString &str)
{
str.replace("xx",""); // simple but atm best working
}
static TQString removedXX(TQString str)
{
if (xxMode)
removeXX(str);
return str;
}
static TQString stripAccelViolations(TQString str)
{
int conflict_pos = str.find("(&&)");
if (conflict_pos >= 0)
{
str = str.mid(0, conflict_pos) + str.mid(conflict_pos+4);
}
int suggestion_pos = str.find("(!)");
if (suggestion_pos >= 0)
{
str = str.mid(0, suggestion_pos) + str.mid(suggestion_pos+3);
}
return str;
}
// Must be passed a string with its accelerators removed
TQString findAccelViolations(TQString str, TQValueVector<StyleGuideViolation> &violations)
{
int conflict_pos = str.find("(&)");
if (conflict_pos >= 0)
str = str.mid(0, conflict_pos) + str.mid(conflict_pos+3);
int suggestion_pos = str.find("(!)");
if (suggestion_pos >= 0)
{
str = str.mid(0, suggestion_pos) + str.mid(suggestion_pos+3);
violations.push_back(StyleGuideViolation(suggestion_pos, StyleGuideViolation::AccelSuggestion));
// Conditionally "relocate" the conflict
if (conflict_pos >= suggestion_pos)
{
conflict_pos -= 3;
}
}
if (conflict_pos >= 0)
violations.push_back(StyleGuideViolation(conflict_pos, StyleGuideViolation::AccelConflict));
return str;
}
TQString findUntranslatedViolations(TQString str, TQValueVector<StyleGuideViolation> &violations)
{
if (str.find("xx")!=-1)
removeXX(str);
else {
for (unsigned int c=0; c<str.length(); c++)
violations.push_back(StyleGuideViolation(c, StyleGuideViolation::Untranslated));
}
return str;
}
static TQValueVector<StyleGuideViolation> checkSentenceStyle(TQString str, ColonMode mode = ColonlessWidget, AccelMode accelMode = HasAccels)
{
TQValueVector<StyleGuideViolation> violations;
bool afterWhiteSpace = true;
bool firstChar = true;
bool inQuote = false;
if (xxMode)
str = findUntranslatedViolations(str, violations);
if (accelMode == HasAccels)
{
// We care not for accelerators while parsing for capitialization
removeAccelerators(str);
str = findAccelViolations(str, violations);
}
for (unsigned int c=0; c<str.length(); c++)
{
// Don't parse within quotes
if (inQuote)
{
if (str[c] == '\"')
{
// The quote is over, return to normal operation
inQuote = false;
afterWhiteSpace = false;
continue;
}
}
else if (str[c].isSpace())
{
if (afterWhiteSpace)
{
// Discourage multiple spaces
violations.push_back(c);
}
afterWhiteSpace = true;
}
else if (str[c] == '\"')
{
// Beginning of a quote
// This disables parsing until the next quotation mark is found
inQuote = true;
afterWhiteSpace = false;
firstChar = false;
}
else if ((str[c] == '.') || (str[c] == ':') || (str[c] == ';') || (str[c] == '?') || (str[c] == '!') || (str[c] == ','))
{
// Is this a new sentence?
if ((str[c] == '.') || (str[c] == '?') || (str[c] == '!'))
{
// Periods not followed by whitespace are probably
// separators in IP addresses or URLs, and they don't
// need any more false positives than they already
// have ;)
if (((c + 1) < str.length()) && (str[c + 1].isSpace()))
{
// We're a new sentence
firstChar = true;
}
}
if (afterWhiteSpace && c)
{
// Tsk tsk, we shouldn't have punctuation after whitespace
violations.push_back(c - 1);
}
afterWhiteSpace = false;
}
else
{
if (afterWhiteSpace) //We don't check for fOO and things like that, just first letters..
{
// Try to extract the whole word..
TQString word = TQString();
for (unsigned int l = c+1; l<str.length(); l++)
{
if (!str[l].isLetter() && !str[l].isNumber() && str[l] != '&' && str[l] != '-')
{
word = str.mid(c, l - c);
break;
}
}
if (word.isNull()) //Looks like goes to end of string..
{
word = str.mid ( c );
}
// Check if it's in the explicit case word list
const char *correctWord = ExplicitCaseWords::words()->find(word.lower());
// Actual captialization checking
if (correctWord)
{
// We have been told explictly how to capitalize this word
// This overides the next checks
for (unsigned int x = 0;x < word.length();x++)
{
if (word[x] != correctWord[x])
{
violations.push_back(c + x);
}
}
}
else if (str[c].category() == TQChar::Letter_Lowercase) //Lowercase character..
{
if (firstChar)
violations.push_back(c);
}
else if (str[c].category() == TQChar::Letter_Uppercase)
{
if (!firstChar) //A possible violation -- can be a proper name..
{
//Check whether more capitalized words in here.. To guess acronyms.
bool acronym = false;
for (unsigned int d = c+1; d < str.length(); d++)
{
if (str[d].isSpace() )
break;
if (str[d].category() == TQChar::Letter_Uppercase)
{
acronym = true;
break;
}
}
if (!acronym)
violations.push_back(c);
}
}
}
firstChar = false;
afterWhiteSpace = false;
}
}
bool endWithColon = false;
int colonIndex = -1;
for (int c = str.length() - 1; c>=0; c--)
{
if (str[c] == ':')
{
endWithColon = true;
colonIndex = c;
break;
}
if (!str[c].isSpace())
break;
}
if ( mode == ColonlessWidget && endWithColon) //Sometimes checkbox is also a label.. So we'll make a colon a warning
{
violations.push_back(StyleGuideViolation(colonIndex,StyleGuideViolation::Warning));
}
if (mode == BuddiedWidget && !endWithColon) //We have a buddy but lack a colon --> wrong
{
violations.push_back(-1);
}
if (mode == BuddylessWidget && endWithColon) //We have no buddy but we do have a colon -- potential error
{
violations.push_back(StyleGuideViolation(colonIndex,StyleGuideViolation::Warning));
}
return violations;
}
static TQValueVector<StyleGuideViolation> checkTitleStyle(TQString str, TitleType titleType = ShortTitle, AccelMode accelMode = NoAccels)
{
TQValueVector<StyleGuideViolation> violations;
bool afterWhiteSpace = true;
if (xxMode)
str = findUntranslatedViolations(str, violations);
if (accelMode == HasAccels)
{
// We care not for accelerators while parsing for capitialization
removeAccelerators(str);
str = findAccelViolations(str, violations);
}
for (unsigned int c=0; c<str.length(); c++)
{
if (str[c].isSpace())
{
if (afterWhiteSpace)
{
// Discourage multiple spaces
violations.push_back(c);
}
afterWhiteSpace = true;
}
else if ((str[c] == '.') || (str[c] == ';') || (str[c] == '?') || (str[c] == '!'))
{
// '!' Is used for marking conficting accels
if ((accelMode = HasAccels) && (str[c] == '!'))
{
afterWhiteSpace = false;
continue;
}
// Periods/colons not followed by whitespace are probably
// separators in IP addresses or URLs, and they don't
// need any more false positives than they already
// have ;)
// Check for multiple sentences
if (((c + 1) < str.length()) && (str[c + 1].isSpace()))
{
violations.push_back(c);
continue;
}
// Check for sentence punctuation at the end of a string,
// being sure not to tag ellipses
if ((c == str.length() - 1) && (str.right(3) != "..."))
violations.push_back(c);
}
else
{
if (c==str.length()-1 && str[c] == ':')
{
violations.push_back(c);
continue;
}
if (afterWhiteSpace) //We don't check for fOO and things like that, just first letters..
{
bool lastWord = false;
//Now, try to extract the whole word..
TQString word = TQString();
for (unsigned int l = c+1; l<str.length(); l++)
{
if (!str[l].isLetter() && !str[l].isNumber() && str[l] != '&' && str[l] != '-')
{
word = str.mid(c, l - c);
if (str.mid(l)=="...")
lastWord=true;
break;
}
}
if (word.isNull()) //Looks like goes to end of string..
{
word = str.mid ( c );
lastWord = true;
}
TQString lower_word = word.lower();
// Check if it's in the explicit case word list
const char *correctWord = ExplicitCaseWords::words()->find(lower_word);
if ((titleType == ShortTitle) && (lower_word=="and" || lower_word=="a" || lower_word=="an" || lower_word=="the"))
{
// This words are 'red flagged' for short titles
for (unsigned int i = 0;i < word.length();i++)
violations.push_back(StyleGuideViolation(c + i,StyleGuideViolation::Warning));
}
if (correctWord)
{
// We're an uppercase word, and may have an unusual
// capitalization (ie, JavaScript)
for (unsigned int x = 0;x < word.length();x++)
{
if (word[x] != correctWord[x])
violations.push_back(c + x);
}
}
else if (c && !lastWord && LowerCaseWords::words()->find(word.lower()))
{
// We're a lowercase word
if (str[c].category() == TQChar::Letter_Uppercase)
violations.push_back(c);
}
else
{
if (str[c].category() == TQChar::Letter_Lowercase)
violations.push_back(c);
}
}
afterWhiteSpace = false;
}
}
return violations;
}
static void renderViolations(const TQValueVector<StyleGuideViolation>& violations, TQPainter* p, TQRect r, int flags, TQString text)
{
if (xxMode)
removeXX(text);
if (violations.size()>0)
{
p->save();
TQFontMetrics qfm = p->fontMetrics ();
TQString parStr = text;
int len = text.length();
/*****
Begin code snipped from TQPainter, somewhat modified
*/
// str.setLength() always does a deep copy, so the replacement code below is safe.
parStr.setLength( len );
// compatible behaviour to the old implementation. Replace tabs by spaces
TQChar *chr = (TQChar*)parStr.unicode();
int l = len;
while ( l-- )
{
if ( *chr == '\t' || *chr == '\r' || *chr == '\n' )
*chr = ' ';
chr++;
}
if ( flags & TQt::ShowPrefix )
{
parStr = removedXX(stripAccelViolations(parStr));
removeAccelerators(parStr);
}
int w = qfm.width( parStr );
int h = qfm.height();
int xoff = r.x();
int yoff = r.y() + qfm.ascent();
if ( flags & TQt::AlignBottom )
yoff += r.height() - h;
else if ( flags & TQt::AlignVCenter )
yoff += ( r.height() - h ) / 2;
if ( flags & TQt::AlignRight )
xoff += r.width() - w;
else if ( flags & TQt::AlignHCenter )
xoff += ( r.width() - w ) / 2;
/*****
end code snipped from TQPainter...
*/
int yt = yoff - h;
int yb = yoff;;
TQRect bnd(xoff, yoff - h, w, h);
for (unsigned int v = 0; v < violations.size(); v++)
{
if (violations[v] != -1)
{
int left = bnd.left() +
qfm.width(parStr, violations[v]) - 1;
int right = bnd.left() +
qfm.width(parStr, violations[v] + 1) - 1;
//int right = r.x() + qfm.width(text, violations[v]+1);
//int left = r.x() + qfm.width(text, violations[v]);
p->fillRect( left, yt, right - left + 1, yb - yt + 1, severityColor(violations[v].severity()) );
}
else
{
int right = bnd.right();
int centerX = right - 1;
int leftX = centerX-h/4;
int rightX = centerX + h/4;
p->setPen(severityColor(violations[v].severity()));
p->drawLine ( leftX, yt + 1, rightX, yt + 1 );
p->drawLine ( leftX, yt + h/2, rightX, yt + h/2 + 1);
p->drawLine ( leftX, yt+ 1, leftX, yt + h/2 + 1);
p->drawLine ( rightX, yt+ 1, rightX, yt + h/2 + 1);
p->drawLine ( leftX, yb - h/2, rightX, yb - h/2);
p->drawLine ( leftX, yb, rightX, yb);
p->drawLine ( leftX, yb - h/2, leftX, yb);
p->drawLine ( rightX, yb - h/2, rightX, yb);
}
}
p->restore();
}
}
StyleCheckTitleWatcher::StyleCheckTitleWatcher()
{
TQTimer* checkTimer = new TQTimer(this);
connect( checkTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotCheck()) );
checkTimer->start(1000);
}
void StyleCheckTitleWatcher::addWatched(TQWidget* w)
{
watched.push_back(w);
watchedTitles.push_back(w->caption());
}
TQString StyleCheckTitleWatcher::cleanErrorMarkers(TQString in)
{
//We add # to denote an error...So now remove it.. It helps us check whether it's the same caption as before..
TQString out = "";
for (unsigned int c = 0; c < in.length(); c++)
{
if (in[c] != '|')
out += in[c];
}
return out;
}
void StyleCheckTitleWatcher::slotCheck()
{
for (unsigned int c=0; c<watched.size(); c++)
{
if (!watched[c].isNull() )
{
TQString cleaned = cleanErrorMarkers(watched[c]->caption());
if (cleaned != watchedTitles[c])
{
watchedTitles[c] = watched[c]->caption();
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(watched[c]->caption(), LongTitle, NoAccels);
if (violations.size() == 0)
continue;
TQString out = "";
TQString in = watched[c]->caption();
int prev = -1;
for (unsigned int v = 0; v < violations.size(); v++)
{
out += in.mid(prev + 1, violations[v] - prev - 1); //Add interval that followed last one..
out += '|';
out += in[violations[v]];
out += '|';
prev = violations[v];
}
out += in.mid(prev + 1); //Add the tail..
watched[c]->setCaption(out);
} //If changed.
} //If not null..
} //for all watched
}
StyleCheckStyle::StyleCheckStyle( )
: KStyle( 0 , ThreeButtonScrollBar )
{
hoverWidget = 0L;
topLevelAccelManageTimer = new TQTimer(this);
connect(topLevelAccelManageTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotAccelManage()));
watcher = new StyleCheckTitleWatcher;
xxMode = (TQString(getenv("KDE_LANG"))=="xx");
}
StyleCheckStyle::~StyleCheckStyle()
{
delete watcher;
}
//We walk down the widget tree until we find something we render, and sic KAccelManager in programmer's mode on those
void StyleCheckStyle::accelManageRecursive(TQWidget* widget)
{
if (&widget->style() == this)
{
KAcceleratorManager::manage(widget, true);
return;
}
const TQObjectList children = widget->childrenListObject();
if (children.isEmpty())
return;
TQObjectListIterator iter(children);
TQObject* walk;
while ((walk = iter.current()))
{
if (walk->isWidgetType())
accelManageRecursive(TQT_TQWIDGET(walk));
++iter;
}
}
void StyleCheckStyle::slotAccelManage()
{
//Walk through top-levels
TQWidgetList* topLevels = TQApplication::topLevelWidgets();
if (!topLevels)
return;
TQWidgetListIt iter(*topLevels);
TQWidget* walk;
while ((walk = iter.current()))
{
accelManageRecursive(walk);
++iter;
}
}
void StyleCheckStyle::polish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
{
/* Having a global view on the widget makes accel
easier to catch. However, just intruding on the main window
is wrong since a style can be used for a subwindow. The upshot is that we defer
accel management to a timer, until things stabilize, and then walk from top-levels down
*/
topLevelAccelManageTimer->start(200, true);
//
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
// Put in order of highest occurance to maximise hit rate
if (widget->inherits(TQPUSHBUTTON_OBJECT_NAME_STRING)) {
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
if (widget->inherits(TQLABEL_OBJECT_NAME_STRING))
{
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
if (widget->inherits(TQGROUPBOX_OBJECT_NAME_STRING))
{
installObjectEventHandler(ceData, elementFlags, ptr, this);
}
if (widget->inherits(TQMAINWINDOW_OBJECT_NAME_STRING) || widget->inherits(TQDIALOG_OBJECT_NAME_STRING) )
{
watcher->addWatched(widget);
}
}
KStyle::polish( ceData, elementFlags, ptr );
}
void StyleCheckStyle::unPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
{
if (ceData.widgetObjectTypes.contains(TQWIDGET_OBJECT_NAME_STRING)) {
TQWidget *widget = reinterpret_cast<TQWidget*>(ptr);
if (widget->inherits(TQPUSHBUTTON_OBJECT_NAME_STRING)) {
removeObjectEventHandler(ceData, elementFlags, ptr, this);
}
if (widget->inherits(TQLABEL_OBJECT_NAME_STRING))
{
removeObjectEventHandler(ceData, elementFlags, ptr, this);
}
if (widget->inherits(TQGROUPBOX_OBJECT_NAME_STRING))
{
removeObjectEventHandler(ceData, elementFlags, ptr, this);
}
}
KStyle::unPolish( ceData, elementFlags, ptr );
}
// This function draws primitive elements as well as their masks.
void StyleCheckStyle::drawPrimitive( PrimitiveElement pe,
TQPainter *p,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption& opt ) const
{
bool down = flags & Style_Down;
bool on = flags & Style_On;
switch(pe)
{
// BUTTONS
// -------------------------------------------------------------------
case PE_ButtonDefault: {
int x1, y1, x2, y2;
r.coords( &x1, &y1, &x2, &y2 );
// Button default indicator
p->setPen( cg.shadow() );
p->drawLine( x1+1, y1, x2-1, y1 );
p->drawLine( x1, y1+1, x1, y2-1 );
p->drawLine( x1+1, y2, x2-1, y2 );
p->drawLine( x2, y1+1, x2, y2-1 );
break;
}
case PE_ButtonDropDown:
case PE_ButtonTool: {
bool sunken = on || down;
int x,y,w,h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
TQPen oldPen = p->pen();
// Outer frame (round style)
p->setPen(cg.shadow());
p->drawLine(x+1,y,x2-1,y);
p->drawLine(x,y+1,x,y2-1);
p->drawLine(x+1,y2,x2-1,y2);
p->drawLine(x2,y+1,x2,y2-1);
// Bevel
p->setPen(sunken ? cg.mid() : cg.light());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+1, x+1, y2-1);
p->setPen(sunken ? cg.light() : cg.mid());
p->drawLine(x+2, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+2, x2-1, y2-1);
p->fillRect(x+2, y+2, w-4, h-4, cg.button());
p->setPen( oldPen );
break;
}
// PUSH BUTTON
// -------------------------------------------------------------------
case PE_ButtonCommand: {
bool sunken = on || down;
int x, y, w, h;
r.rect(&x, &y, &w, &h);
if ( sunken )
kDrawBeButton( p, x, y, w, h, cg, true,
&cg.brush(TQColorGroup::Mid) );
else if ( flags & Style_MouseOver ) {
TQBrush brush(cg.button().light(110));
kDrawBeButton( p, x, y, w, h, cg, false, &brush );
}
// "Flat" button
else if (!(flags & (Style_Raised | Style_Sunken)))
p->fillRect(r, cg.button());
else
kDrawBeButton(p, x, y, w, h, cg, false,
&cg.brush(TQColorGroup::Button));
break;
}
// BEVELS
// -------------------------------------------------------------------
case PE_ButtonBevel: {
int x,y,w,h;
r.rect(&x, &y, &w, &h);
bool sunken = on || down;
int x2 = x+w-1;
int y2 = y+h-1;
// Outer frame
p->setPen(cg.shadow());
p->drawRect(r);
// Bevel
p->setPen(sunken ? cg.mid() : cg.light());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+1, x+1, y2-1);
p->setPen(sunken ? cg.light() : cg.mid());
p->drawLine(x+2, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+2, x2-1, y2-1);
if (w > 4 && h > 4) {
if (sunken)
p->fillRect(x+2, y+2, w-4, h-4, cg.button());
else
renderGradient( p, TQRect(x+2, y+2, w-4, h-4),
cg.button(), flags & Style_Horizontal );
}
break;
}
// FOCUS RECT
// -------------------------------------------------------------------
case PE_FocusRect: {
p->drawWinFocusRect( r );
break;
}
// HEADER SECTION
// -------------------------------------------------------------------
case PE_HeaderSection: {
// Temporary solution for the proper orientation of gradients.
bool horizontal = true;
if (p && p->device()->devType() == TQInternal::Widget) {
TQHeader* hdr = dynamic_cast<TQHeader*>(p->device());
if (hdr)
horizontal = hdr->orientation() ==Qt::Horizontal;
}
int x,y,w,h;
r.rect(&x, &y, &w, &h);
bool sunken = on || down;
int x2 = x+w-1;
int y2 = y+h-1;
TQPen oldPen = p->pen();
// Bevel
p->setPen(sunken ? cg.mid() : cg.light());
p->drawLine(x, y, x2-1, y);
p->drawLine(x, y, x, y2-1);
p->setPen(sunken ? cg.light() : cg.mid());
p->drawLine(x+1, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+1, x2-1, y2-1);
p->setPen(cg.shadow());
p->drawLine(x, y2, x2, y2);
p->drawLine(x2, y, x2, y2);
if (sunken)
p->fillRect(x+1, y+1, w-3, h-3, cg.button());
else
renderGradient( p, TQRect(x+1, y+1, w-3, h-3),
cg.button(), !horizontal );
p->setPen( oldPen );
break;
}
// SCROLLBAR
// -------------------------------------------------------------------
case PE_ScrollBarSlider: {
// Small hack to ensure scrollbar gradients are drawn the right way.
flags ^= Style_Horizontal;
drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, flags | Style_Enabled | Style_Raised);
// Draw a scrollbar riffle (note direction after above changes)
// HighColor & Default scrollbar
if (flags & Style_Horizontal) {
if (r.height() >= 15) {
int x = r.x()+3;
int y = r.y() + (r.height()-7)/2;
int x2 = r.right()-3;
p->setPen(cg.light());
p->drawLine(x, y, x2, y);
p->drawLine(x, y+3, x2, y+3);
p->drawLine(x, y+6, x2, y+6);
p->setPen(cg.mid());
p->drawLine(x, y+1, x2, y+1);
p->drawLine(x, y+4, x2, y+4);
p->drawLine(x, y+7, x2, y+7);
}
} else {
if (r.width() >= 15) {
int y = r.y()+3;
int x = r.x() + (r.width()-7)/2;
int y2 = r.bottom()-3;
p->setPen(cg.light());
p->drawLine(x, y, x, y2);
p->drawLine(x+3, y, x+3, y2);
p->drawLine(x+6, y, x+6, y2);
p->setPen(cg.mid());
p->drawLine(x+1, y, x+1, y2);
p->drawLine(x+4, y, x+4, y2);
p->drawLine(x+7, y, x+7, y2);
}
}
break;
}
case PE_ScrollBarAddPage:
case PE_ScrollBarSubPage: {
int x, y, w, h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(cg.shadow());
if (flags & Style_Horizontal) {
p->drawLine(x, y, x2, y);
p->drawLine(x, y2, x2, y2);
renderGradient(p, TQRect(x, y+1, w, h-2),
cg.mid(), false);
} else {
p->drawLine(x, y, x, y2);
p->drawLine(x2, y, x2, y2);
renderGradient(p, TQRect(x+1, y, w-2, h),
cg.mid(), true);
}
break;
}
case PE_ScrollBarAddLine: {
drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg, (flags & Style_Enabled) |
((flags & Style_Down) ? Style_Down : Style_Raised) );
drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
p, ceData, elementFlags, r, cg, flags );
break;
}
case PE_ScrollBarSubLine: {
drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg, (flags & Style_Enabled) |
((flags & Style_Down) ? Style_Down : Style_Raised) );
drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
p, ceData, elementFlags, r, cg, flags );
break;
}
// CHECKBOX (indicator)
// -------------------------------------------------------------------
case PE_Indicator: {
bool enabled = flags & Style_Enabled;
bool nochange = flags & Style_NoChange;
if (xBmp.isNull()) {
xBmp = TQBitmap(7, 7, x_bits, true);
xBmp.setMask(xBmp);
}
int x,y,w,h;
x=r.x(); y=r.y(); w=r.width(); h=r.height();
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(cg.mid());
p->drawLine(x, y, x2, y);
p->drawLine(x, y, x, y2);
p->setPen(cg.light());
p->drawLine(x2, y+1, x2, y2);
p->drawLine(x+1, y2, x2, y2);
p->setPen(cg.shadow());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+1, x+1, y2-1);
p->setPen(cg.midlight());
p->drawLine(x2-1, y+2, x2-1, y2-1);
p->drawLine(x+2, y2-1, x2-1, y2-1);
if ( enabled )
p->fillRect(x+2, y+2, w-4, h-4,
down ? cg.button(): cg.base());
else
p->fillRect(x+2, y+2, w-4, h-4, cg.background());
if (!(flags & Style_Off)) {
if (on) {
p->setPen(nochange ? cg.dark() : cg.text());
p->drawPixmap(x+3, y+3, xBmp);
}
else {
p->setPen(cg.shadow());
p->drawRect(x+2, y+2, w-4, h-4);
p->setPen(nochange ? cg.text() : cg.dark());
p->drawLine(x+3, (y+h)/2-2, x+w-4, (y+h)/2-2);
p->drawLine(x+3, (y+h)/2, x+w-4, (y+h)/2);
p->drawLine(x+3, (y+h)/2+2, x+w-4, (y+h)/2+2);
}
}
break;
}
// RADIOBUTTON (exclusive indicator)
// -------------------------------------------------------------------
case PE_ExclusiveIndicator: {
if (lightBmp.isNull()) {
lightBmp = TQBitmap(13, 13, radiooff_light_bits, true);
grayBmp = TQBitmap(13, 13, radiooff_gray_bits, true);
dgrayBmp = TQBitmap(13, 13, radiooff_dgray_bits, true);
centerBmp = TQBitmap(13, 13, radiooff_center_bits, true);
centerBmp.setMask( centerBmp );
}
// Bevel
kColorBitmaps(p, cg, r.x(), r.y(), &lightBmp , &grayBmp,
NULL, &dgrayBmp);
// The center fill of the indicator (grayed out when disabled)
if ( flags & Style_Enabled )
p->setPen( down ? cg.button() : cg.base() );
else
p->setPen( cg.background() );
p->drawPixmap( r.x(), r.y(), centerBmp );
// Indicator "dot"
if ( on ) {
TQColor color = flags & Style_NoChange ?
cg.dark() : cg.text();
p->setPen(color);
p->drawLine(5, 4, 7, 4);
p->drawLine(4, 5, 4, 7);
p->drawLine(5, 8, 7, 8);
p->drawLine(8, 5, 8, 7);
p->fillRect(5, 5, 3, 3, color);
}
break;
}
// RADIOBUTTON (exclusive indicator) mask
// -------------------------------------------------------------------
case PE_ExclusiveIndicatorMask: {
if (maskBmp.isNull()) {
maskBmp = TQBitmap(13, 13, radiomask_bits, true);
maskBmp.setMask(maskBmp);
}
p->setPen(TQt::color1);
p->drawPixmap(r.x(), r.y(), maskBmp);
break;
}
// SPLITTER/DOCKWINDOW HANDLES
// -------------------------------------------------------------------
case PE_DockWindowResizeHandle:
case PE_Splitter: {
int x,y,w,h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(cg.dark());
p->drawRect(x, y, w, h);
p->setPen(cg.background());
p->drawPoint(x, y);
p->drawPoint(x2, y);
p->drawPoint(x, y2);
p->drawPoint(x2, y2);
p->setPen(cg.light());
p->drawLine(x+1, y+1, x+1, y2-1);
p->drawLine(x+1, y+1, x2-1, y+1);
p->setPen(cg.midlight());
p->drawLine(x+2, y+2, x+2, y2-2);
p->drawLine(x+2, y+2, x2-2, y+2);
p->setPen(cg.mid());
p->drawLine(x2-1, y+1, x2-1, y2-1);
p->drawLine(x+1, y2-1, x2-1, y2-1);
p->fillRect(x+3, y+3, w-5, h-5, cg.brush(TQColorGroup::Background));
break;
}
// GENERAL PANELS
// -------------------------------------------------------------------
case PE_Panel:
case PE_PanelPopup:
case PE_WindowFrame:
case PE_PanelLineEdit: {
bool sunken = flags & Style_Sunken;
int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags)
: opt.lineWidth();
if (lw == 2)
{
TQPen oldPen = p->pen();
int x,y,w,h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(sunken ? cg.light() : cg.dark());
p->drawLine(x, y2, x2, y2);
p->drawLine(x2, y, x2, y2);
p->setPen(sunken ? cg.mid() : cg.light());
p->drawLine(x, y, x2, y);
p->drawLine(x, y, x, y2);
p->setPen(sunken ? cg.midlight() : cg.mid());
p->drawLine(x+1, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+1, x2-1, y2-1);
p->setPen(sunken ? cg.dark() : cg.midlight());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+1, x+1, y2-1);
p->setPen(oldPen);
} else
KStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
break;
}
// MENU / TOOLBAR PANEL
// -------------------------------------------------------------------
case PE_PanelMenuBar: // Menu
case PE_PanelDockWindow: { // Toolbar
int x2 = r.x()+r.width()-1;
int y2 = r.y()+r.height()-1;
if (opt.lineWidth())
{
p->setPen(cg.light());
p->drawLine(r.x(), r.y(), x2-1, r.y());
p->drawLine(r.x(), r.y(), r.x(), y2-1);
p->setPen(cg.dark());
p->drawLine(r.x(), y2, x2, y2);
p->drawLine(x2, r.y(), x2, y2);
// ### TQt should specify Style_Horizontal where appropriate
renderGradient( p, TQRect(r.x()+1, r.y()+1, x2-1, y2-1),
cg.button(), (r.width() < r.height()) &&
(pe != PE_PanelMenuBar) );
}
else
{
renderGradient( p, TQRect(r.x(), r.y(), x2, y2),
cg.button(), (r.width() < r.height()) &&
(pe != PE_PanelMenuBar) );
}
break;
}
// TOOLBAR SEPARATOR
// -------------------------------------------------------------------
case PE_DockWindowSeparator: {
renderGradient( p, r, cg.button(),
!(flags & Style_Horizontal));
if ( !(flags & Style_Horizontal) ) {
p->setPen(cg.mid());
p->drawLine(4, r.height()/2, r.width()-5, r.height()/2);
p->setPen(cg.light());
p->drawLine(4, r.height()/2+1, r.width()-5, r.height()/2+1);
} else {
p->setPen(cg.mid());
p->drawLine(r.width()/2, 4, r.width()/2, r.height()-5);
p->setPen(cg.light());
p->drawLine(r.width()/2+1, 4, r.width()/2+1, r.height()-5);
}
break;
}
default:
{
// ARROWS
// -------------------------------------------------------------------
if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft)
{
TQPointArray a;
// HighColor & Default arrows
switch(pe) {
case PE_ArrowUp:
a.setPoints(TQCOORDARRLEN(u_arrow), u_arrow);
break;
case PE_ArrowDown:
a.setPoints(TQCOORDARRLEN(d_arrow), d_arrow);
break;
case PE_ArrowLeft:
a.setPoints(TQCOORDARRLEN(l_arrow), l_arrow);
break;
default:
a.setPoints(TQCOORDARRLEN(r_arrow), r_arrow);
}
p->save();
if ( flags & Style_Down )
p->translate( pixelMetric( PM_ButtonShiftHorizontal, ceData, elementFlags ),
pixelMetric( PM_ButtonShiftVertical, ceData, elementFlags ) );
if ( flags & Style_Enabled ) {
a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 );
p->setPen( cg.buttonText() );
p->drawLineSegments( a );
} else {
a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 );
p->setPen( cg.light() );
p->drawLineSegments( a );
a.translate( -1, -1 );
p->setPen( cg.mid() );
p->drawLineSegments( a );
}
p->restore();
} else
KStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
}
}
}
void StyleCheckStyle::drawKStylePrimitive( KStylePrimitive kpe,
TQPainter* p,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption &opt,
const TQWidget* widget ) const
{
switch ( kpe )
{
// TOOLBAR HANDLE
// -------------------------------------------------------------------
case KPE_ToolBarHandle: {
int x = r.x(); int y = r.y();
int x2 = r.x() + r.width()-1;
int y2 = r.y() + r.height()-1;
if (flags & Style_Horizontal) {
renderGradient( p, r, cg.button(), false);
p->setPen(cg.light());
p->drawLine(x+1, y+4, x+1, y2-4);
p->drawLine(x+3, y+4, x+3, y2-4);
p->drawLine(x+5, y+4, x+5, y2-4);
p->setPen(cg.mid());
p->drawLine(x+2, y+4, x+2, y2-4);
p->drawLine(x+4, y+4, x+4, y2-4);
p->drawLine(x+6, y+4, x+6, y2-4);
} else {
renderGradient( p, r, cg.button(), true);
p->setPen(cg.light());
p->drawLine(x+4, y+1, x2-4, y+1);
p->drawLine(x+4, y+3, x2-4, y+3);
p->drawLine(x+4, y+5, x2-4, y+5);
p->setPen(cg.mid());
p->drawLine(x+4, y+2, x2-4, y+2);
p->drawLine(x+4, y+4, x2-4, y+4);
p->drawLine(x+4, y+6, x2-4, y+6);
}
break;
}
// GENERAL/KICKER HANDLE
// -------------------------------------------------------------------
case KPE_GeneralHandle: {
int x = r.x(); int y = r.y();
int x2 = r.x() + r.width()-1;
int y2 = r.y() + r.height()-1;
if (flags & Style_Horizontal) {
p->setPen(cg.light());
p->drawLine(x+1, y, x+1, y2);
p->drawLine(x+3, y, x+3, y2);
p->drawLine(x+5, y, x+5, y2);
p->setPen(cg.mid());
p->drawLine(x+2, y, x+2, y2);
p->drawLine(x+4, y, x+4, y2);
p->drawLine(x+6, y, x+6, y2);
} else {
p->setPen(cg.light());
p->drawLine(x, y+1, x2, y+1);
p->drawLine(x, y+3, x2, y+3);
p->drawLine(x, y+5, x2, y+5);
p->setPen(cg.mid());
p->drawLine(x, y+2, x2, y+2);
p->drawLine(x, y+4, x2, y+4);
p->drawLine(x, y+6, x2, y+6);
}
break;
}
// SLIDER GROOVE
// -------------------------------------------------------------------
case KPE_SliderGroove: {
const TQSlider* slider = (const TQSlider*)widget;
bool horizontal = slider->orientation() ==Qt::Horizontal;
int gcenter = (horizontal ? r.height() : r.width()) / 2;
TQRect gr;
if (horizontal)
gr = TQRect(r.x(), r.y()+gcenter-3, r.width(), 7);
else
gr = TQRect(r.x()+gcenter-3, r.y(), 7, r.height());
int x,y,w,h;
gr.rect(&x, &y, &w, &h);
int x2=x+w-1;
int y2=y+h-1;
// Draw the slider groove.
p->setPen(cg.dark());
p->drawLine(x+2, y, x2-2, y);
p->drawLine(x, y+2, x, y2-2);
p->fillRect(x+2,y+2,w-4, h-4,
slider->isEnabled() ? cg.dark() : cg.mid());
p->setPen(cg.shadow());
p->drawRect(x+1, y+1, w-2, h-2);
p->setPen(cg.light());
p->drawPoint(x+1,y2-1);
p->drawPoint(x2-1,y2-1);
p->drawLine(x2, y+2, x2, y2-2);
p->drawLine(x+2, y2, x2-2, y2);
break;
}
// SLIDER HANDLE
// -------------------------------------------------------------------
case KPE_SliderHandle: {
const TQSlider* slider = (const TQSlider*)widget;
bool horizontal = slider->orientation() ==Qt::Horizontal;
int x,y,w,h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(cg.mid());
p->drawLine(x+1, y, x2-1, y);
p->drawLine(x, y+1, x, y2-1);
p->setPen(cg.shadow());
p->drawLine(x+1, y2, x2-1, y2);
p->drawLine(x2, y+1, x2, y2-1);
p->setPen(cg.light());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+1, x+1, y2-1);
p->setPen(cg.dark());
p->drawLine(x+2, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+2, x2-1, y2-1);
p->setPen(cg.midlight());
p->drawLine(x+2, y+2, x2-2, y+2);
p->drawLine(x+2, y+2, x+2, y2-2);
p->setPen(cg.mid());
p->drawLine(x+3, y2-2, x2-2, y2-2);
p->drawLine(x2-2, y+3, x2-2, y2-2);
renderGradient(p, TQRect(x+3, y+3, w-6, h-6),
cg.button(), !horizontal);
// Paint riffles
if (horizontal) {
p->setPen(cg.light());
p->drawLine(x+5, y+4, x+5, y2-4);
p->drawLine(x+8, y+4, x+8, y2-4);
p->drawLine(x+11,y+4, x+11, y2-4);
p->setPen(slider->isEnabled() ? cg.shadow(): cg.mid());
p->drawLine(x+6, y+4, x+6, y2-4);
p->drawLine(x+9, y+4, x+9, y2-4);
p->drawLine(x+12,y+4, x+12, y2-4);
} else {
p->setPen(cg.light());
p->drawLine(x+4, y+5, x2-4, y+5);
p->drawLine(x+4, y+8, x2-4, y+8);
p->drawLine(x+4, y+11, x2-4, y+11);
p->setPen(slider->isEnabled() ? cg.shadow() : cg.mid());
p->drawLine(x+4, y+6, x2-4, y+6);
p->drawLine(x+4, y+9, x2-4, y+9);
p->drawLine(x+4, y+12, x2-4, y+12);
}
break;
}
default:
KStyle::drawKStylePrimitive( kpe, p, ceData, elementFlags, r, cg, flags, opt, widget);
}
}
void StyleCheckStyle::drawControl( ControlElement element,
TQPainter *p,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
const TQStyleOption& opt,
const TQWidget *widget ) const
{
switch (element)
{
// PUSHBUTTON
// -------------------------------------------------------------------
case CE_PushButton: {
if ( widget == hoverWidget )
flags |= Style_MouseOver;
TQPushButton *button = (TQPushButton*) widget;
TQRect br = r;
bool btnDefault = button->isDefault();
if ( btnDefault || button->autoDefault() ) {
// Compensate for default indicator
static int di = pixelMetric( PM_ButtonDefaultIndicator, ceData, elementFlags );
br.addCoords( di, di, -di, -di );
}
if ( btnDefault )
drawPrimitive( PE_ButtonDefault, p, ceData, elementFlags, r, cg, flags );
drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, br, cg, flags );
break;
}
// PUSHBUTTON LABEL
// -------------------------------------------------------------------
case CE_PushButtonLabel: {
const TQPushButton* button = (const TQPushButton*)widget;
bool active = button->isOn() || button->isDown();
int x, y, w, h;
r.rect( &x, &y, &w, &h );
// Shift button contents if pushed.
if ( active ) {
x += pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget);
y += pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget);
flags |= Style_Sunken;
}
// Does the button have a popup menu?
if ( button->isMenuButton() ) {
int dx = pixelMetric( PM_MenuButtonIndicator, ceData, elementFlags, widget );
drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, TQRect(x + w - dx - 2, y + 2, dx, h - 4),
cg, flags, opt );
w -= dx;
}
// Draw the icon if there is one
if ( button->iconSet() && !button->iconSet()->isNull() ) {
TQIconSet::Mode mode = TQIconSet::Disabled;
TQIconSet::State state = TQIconSet::Off;
if (button->isEnabled())
mode = button->hasFocus() ? TQIconSet::Active : TQIconSet::Normal;
if (button->isToggleButton() && button->isOn())
state = TQIconSet::On;
TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state );
p->drawPixmap( x + 4, y + h / 2 - pixmap.height() / 2, pixmap );
int pw = pixmap.width();
x += pw + 4;
w -= pw + 4;
}
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(button->text(), ShortTitle, HasAccels);
renderViolations(violations, p, TQRect(x,y,w,h), AlignCenter | ShowPrefix, button->text());
// Make the label indicate if the button is a default button or not
if ( active || button->isDefault() ) {
// Draw "fake" bold text - this enables the font metrics to remain
// the same as computed in TQPushButton::sizeHint(), but gives
// a reasonable bold effect.
int i;
// Text shadow
if (button->isEnabled()) // Don't draw double-shadow when disabled
for(i=0; i<2; i++)
drawItem( p, TQRect(x+i+1, y+1, w, h), AlignCenter | ShowPrefix,
button->colorGroup(), button->isEnabled(), button->pixmap(),
removedXX(stripAccelViolations(button->text())), -1,
active ? &button->colorGroup().dark() : &button->colorGroup().mid() );
// Normal Text
for(i=0; i<2; i++)
drawItem( p, TQRect(x+i, y, w, h), AlignCenter | ShowPrefix,
button->colorGroup(), button->isEnabled(), button->pixmap(),
removedXX(stripAccelViolations(button->text())), -1,
active ? &button->colorGroup().light() : &button->colorGroup().buttonText() );
} else
drawItem( p, TQRect(x, y, w, h), AlignCenter | ShowPrefix, button->colorGroup(),
button->isEnabled(), button->pixmap(), removedXX(stripAccelViolations(button->text())), -1,
active ? &button->colorGroup().light() : &button->colorGroup().buttonText() );
// Draw a focus rect if the button has focus
if ( flags & Style_HasFocus )
drawPrimitive( PE_FocusRect, p, ceData, elementFlags,
TQStyle::visualRect(subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget), ceData, elementFlags),
cg, flags );
break;
}
case CE_TabBarLabel:
{
if ( opt.isDefault() )
break;
const TQTabBar * tb = (const TQTabBar *) widget;
TQTab * t = opt.tab();
TQRect tr = r;
if ( t->identifier() == tb->currentTab() )
tr.setBottom( tr.bottom() -
pixelMetric( TQStyle::PM_DefaultFrameWidth, ceData, elementFlags, tb ) );
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(t->text(), ShortTitle, HasAccels);
renderViolations(violations, p, r, AlignCenter |ShowPrefix, t->text());
drawItem( p, tr, AlignCenter | ShowPrefix, cg,
flags & Style_Enabled, 0, removedXX(stripAccelViolations(t->text())) );
if ( (flags & Style_HasFocus) && !t->text().isEmpty() )
drawPrimitive( PE_FocusRect, p, ceData, elementFlags, r, cg );
break;
}
case CE_CheckBoxLabel:
{
const TQCheckBox* checkbox = static_cast<const TQCheckBox*>(widget);
int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
TQValueVector<StyleGuideViolation> violations = checkSentenceStyle(checkbox->text());
renderViolations(violations, p, r, alignment | AlignVCenter | ShowPrefix, checkbox->text());
drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, checkbox->pixmap(), removedXX(stripAccelViolations(checkbox->text())));
if (flags & Style_HasFocus)
{
TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
}
break;
}
case CE_RadioButtonLabel:
{
const TQRadioButton* rb = static_cast<const TQRadioButton*>(widget);
int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
TQValueVector<StyleGuideViolation> violations = checkSentenceStyle(rb->text());
renderViolations(violations, p, r,alignment | AlignVCenter | ShowPrefix, rb->text());
drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
flags & Style_Enabled, rb->pixmap(), removedXX(stripAccelViolations(rb->text())));
if (flags & Style_HasFocus)
{
TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
}
break;
}
// MENUBAR ITEM (sunken panel on mouse over)
// -------------------------------------------------------------------
case CE_MenuBarItem:
{
TQMenuBar *mb = (TQMenuBar*)widget;
TQMenuItem *mi = opt.menuItem();
TQRect pr = mb->rect();
bool active = flags & Style_Active;
bool focused = flags & Style_HasFocus;
if ( active && focused )
qDrawShadePanel(p, r.x(), r.y(), r.width(), r.height(),
cg, true, 1, &cg.brush(TQColorGroup::Midlight));
else
renderGradient( p, r, cg.button(), false,
r.x(), r.y()-1, pr.width()-2, pr.height()-2);
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(mi->text(), ShortTitle, HasAccels);
renderViolations(violations, p, r, AlignCenter | AlignVCenter | ShowPrefix, mi->text());
drawItem( p, r, AlignCenter | AlignVCenter | ShowPrefix
| DontClip | SingleLine, cg, flags & Style_Enabled,
mi->pixmap(), removedXX(stripAccelViolations(mi->text())) );
break;
}
// POPUPMENU ITEM
// -------------------------------------------------------------------
case CE_PopupMenuItem: {
const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
TQMenuItem *mi = opt.menuItem();
if ( !mi ) {
// Don't leave blank holes if we set NoBackground for the TQPopupMenu.
// This only happens when the popupMenu spans more than one column.
if (! (widget->erasePixmap() && !widget->erasePixmap()->isNull()) )
p->fillRect(r, cg.brush(TQColorGroup::Button) );
break;
}
int tab = opt.tabWidth();
int checkcol = opt.maxIconWidth();
bool enabled = mi->isEnabled();
bool checkable = popupmenu->isCheckable();
bool active = flags & Style_Active;
bool etchtext = styleHint( SH_EtchDisabledText, ceData, elementFlags );
bool reverse = TQApplication::reverseLayout();
int x, y, w, h;
r.rect( &x, &y, &w, &h );
if ( checkable )
checkcol = TQMAX( checkcol, 20 );
// Are we a menu item separator?
if ( mi->isSeparator() ) {
p->setPen( cg.dark() );
p->drawLine( x, y, x+w, y );
p->setPen( cg.light() );
p->drawLine( x, y+1, x+w, y+1 );
break;
}
// Draw the menu item background
if ( active )
qDrawShadePanel( p, x, y, w, h, cg, true, 1,
&cg.brush(TQColorGroup::Midlight) );
// Draw the transparency pixmap
else if ( widget->erasePixmap() && !widget->erasePixmap()->isNull() )
p->drawPixmap( x, y, *widget->erasePixmap(), x, y, w, h );
// Draw a solid background
else
p->fillRect( r, cg.button() );
// Do we have an icon?
if ( mi->iconSet() ) {
TQIconSet::Mode mode;
TQRect cr = visualRect( TQRect(x, y, checkcol, h), r );
// Select the correct icon from the iconset
if ( active )
mode = enabled ? TQIconSet::Active : TQIconSet::Disabled;
else
mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
// Do we have an icon and are checked at the same time?
// Then draw a "pressed" background behind the icon
if ( checkable && !active && mi->isChecked() )
qDrawShadePanel( p, cr.x(), cr.y(), cr.width(), cr.height(),
cg, true, 1, &cg.brush(TQColorGroup::Midlight) );
// Draw the icon
TQPixmap pixmap = mi->iconSet()->pixmap( TQIconSet::Small, mode );
TQRect pmr( 0, 0, pixmap.width(), pixmap.height() );
pmr.moveCenter( cr.center() );
p->drawPixmap( pmr.topLeft(), pixmap );
}
// Are we checked? (This time without an icon)
else if ( checkable && mi->isChecked() ) {
int cx = reverse ? x+w - checkcol : x;
// We only have to draw the background if the menu item is inactive -
// if it's active the "pressed" background is already drawn
if ( ! active )
qDrawShadePanel( p, cx, y, checkcol, h, cg, true, 1,
&cg.brush(TQColorGroup::Midlight) );
// Draw the checkmark
SFlags cflags = Style_Default;
cflags |= active ? Style_Enabled : Style_On;
drawPrimitive( PE_CheckMark, p, ceData, elementFlags, TQRect( cx + itemFrame, y + itemFrame,
checkcol - itemFrame*2, h - itemFrame*2), cg, cflags );
}
// Time to draw the menu item label...
int xm = itemFrame + checkcol + itemHMargin; // X position margin
int xp = reverse ? // X position
x + tab + rightBorder + itemHMargin + itemFrame - 1 :
x + xm;
int offset = reverse ? -1 : 1; // Shadow offset for etched text
// Label width (minus the width of the accelerator portion)
int tw = w - xm - tab - arrowHMargin - itemHMargin * 3 - itemFrame + 1;
// Set the color for enabled and disabled text
// (used for both active and inactive menu items)
p->setPen( enabled ? cg.buttonText() : cg.mid() );
// This color will be used instead of the above if the menu item
// is active and disabled at the same time. (etched text)
TQColor discol = cg.mid();
// Does the menu item draw it's own label?
if ( mi->custom() ) {
int m = itemVMargin;
// Save the painter state in case the custom
// paint method changes it in some way
p->save();
// Draw etched text if we're inactive and the menu item is disabled
if ( etchtext && !enabled && !active ) {
p->setPen( cg.light() );
mi->custom()->paint( p, cg, active, enabled, xp+offset, y+m+1, tw, h-2*m );
p->setPen( discol );
}
mi->custom()->paint( p, cg, active, enabled, xp, y+m, tw, h-2*m );
p->restore();
}
else {
TQValueVector<StyleGuideViolation> ourViolations;
TQString tmpStr = mi->text();
removeAccelerators(tmpStr);
findAccelViolations(tmpStr, ourViolations);
// The menu item doesn't draw it's own label
TQString s = stripAccelViolations(mi->text());
// Does the menu item have a text label?
if ( !s.isNull() ) {
int t = s.find( '\t' );
int m = itemVMargin;
int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine;
text_flags |= reverse ? AlignRight : AlignLeft;
// Does the menu item have a tabstop? (for the accelerator text)
if ( t >= 0 ) {
int tabx = reverse ? x + rightBorder + itemHMargin + itemFrame :
x + w - tab - rightBorder - itemHMargin - itemFrame;
// Draw the right part of the label (accelerator text)
if ( etchtext && !enabled && !active ) {
// Draw etched text if we're inactive and the menu item is disabled
p->setPen( cg.light() );
p->drawText( tabx+offset, y+m+1, tab, h-2*m, text_flags, removedXX(s.mid( t+1 )) );
p->setPen( discol );
}
p->drawText( tabx, y+m, tab, h-2*m, text_flags, removedXX(s.mid( t+1 )) );
s = s.left( t );
}
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(s, ShortTitle, HasAccels);
renderViolations(violations, p, TQRect(xp, y+m, tw, h-2*m), text_flags, s);
renderViolations(ourViolations, p, TQRect(xp, y+m, tw, h-2*m), text_flags, s);
// Draw the left part of the label (or the whole label
// if there's no accelerator)
if ( etchtext && !enabled && !active ) {
// Etched text again for inactive disabled menu items...
p->setPen( cg.light() );
p->drawText( xp+offset, y+m+1, tw, h-2*m, text_flags, removedXX(s)/*, t*/ );
p->setPen( discol );
}
p->drawText( xp, y+m, tw, h-2*m, text_flags, removedXX(s)/*, t*/ );
}
// The menu item doesn't have a text label
// Check if it has a pixmap instead
else if ( mi->pixmap() ) {
TQPixmap *pixmap = mi->pixmap();
// Draw the pixmap
if ( pixmap->depth() == 1 )
p->setBackgroundMode( Qt::OpaqueMode );
int diffw = ( ( w - pixmap->width() ) / 2 )
+ ( ( w - pixmap->width() ) % 2 );
p->drawPixmap( x+diffw, y+itemFrame, *pixmap );
if ( pixmap->depth() == 1 )
p->setBackgroundMode( Qt::TransparentMode );
}
}
// Does the menu item have a submenu?
if ( mi->popup() ) {
PrimitiveElement arrow = reverse ? PE_ArrowLeft : PE_ArrowRight;
int dim = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags);
TQRect vr = visualRect( TQRect( x + w - arrowHMargin - 2*itemFrame - dim,
y + h / 2 - dim / 2, dim, dim), r );
// Draw an arrow at the far end of the menu item
if ( active ) {
if ( enabled )
discol = cg.buttonText();
TQColorGroup g2( discol, cg.highlight(), white, white,
enabled ? white : discol, discol, white );
drawPrimitive( arrow, p, ceData, elementFlags, vr, g2, Style_Enabled );
} else
drawPrimitive( arrow, p, ceData, elementFlags, vr, cg,
enabled ? Style_Enabled : Style_Default );
}
break;
}
case CE_HeaderLabel:
{
//Most of code here shamelessly lifted from TQCommonStyle.
TQRect rect = r;
const TQHeader* header = static_cast<const TQHeader*>(widget);
int section = opt.headerSection();
TQIconSet* icon = header->iconSet( section );
if ( icon )
{
TQPixmap pixmap = icon->pixmap( TQIconSet::Small,
flags & Style_Enabled ? TQIconSet::Normal : TQIconSet::Disabled );
int pixw = pixmap.width();
int pixh = pixmap.height();
// "pixh - 1" because of tricky integer division
TQRect pixRect = rect;
pixRect.setY( rect.center().y() - (pixh - 1) / 2 );
drawItem ( p, pixRect, AlignVCenter, cg, flags & Style_Enabled,
&pixmap, TQString() );
rect.setLeft( rect.left() + pixw + 2 );
}
TQString s = header->label( section );
TQValueVector<StyleGuideViolation> violations = checkTitleStyle(s, ShortTitle, NoAccels);
renderViolations(violations, p, rect, AlignVCenter, s);
drawItem ( p, rect, AlignVCenter, cg, flags & Style_Enabled,
0, s, -1, &(cg.buttonText()) );
break;
}
default:
KStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
}
}
void StyleCheckStyle::drawControlMask( ControlElement element,
TQPainter *p,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQStyleOption& opt,
const TQWidget *widget ) const
{
switch (element)
{
// PUSHBUTTON MASK
// ----------------------------------------------------------------------
case CE_PushButton: {
int x1, y1, x2, y2;
r.coords( &x1, &y1, &x2, &y2 );
TQCOORD corners[] = { x1,y1, x2,y1, x1,y2, x2,y2 };
p->fillRect( r, color1 );
p->setPen( color0 );
p->drawPoints( TQPointArray(4, corners) );
break;
}
default:
KStyle::drawControlMask(element, p, ceData, elementFlags, r, opt, widget);
}
}
void StyleCheckStyle::drawComplexControl( ComplexControl control,
TQPainter *p,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQRect &r,
const TQColorGroup &cg,
SFlags flags,
SCFlags controls,
SCFlags active,
const TQStyleOption& opt,
const TQWidget *widget ) const
{
switch(control)
{
// COMBOBOX
// -------------------------------------------------------------------
case CC_ComboBox: {
// Draw box and arrow
if ( controls & SC_ComboBoxArrow ) {
bool sunken = (active == SC_ComboBoxArrow);
// Draw the combo
int x,y,w,h;
r.rect(&x, &y, &w, &h);
int x2 = x+w-1;
int y2 = y+h-1;
p->setPen(cg.shadow());
p->drawLine(x+1, y, x2-1, y);
p->drawLine(x+1, y2, x2-1, y2);
p->drawLine(x, y+1, x, y2-1);
p->drawLine(x2, y+1, x2, y2-1);
// Ensure the edge notches are properly colored
p->setPen(cg.button());
p->drawPoint(x,y);
p->drawPoint(x,y2);
p->drawPoint(x2,y);
p->drawPoint(x2,y2);
renderGradient( p, TQRect(x+2, y+2, w-4, h-4),
cg.button(), false);
p->setPen(sunken ? cg.light() : cg.mid());
p->drawLine(x2-1, y+2, x2-1, y2-1);
p->drawLine(x+1, y2-1, x2-1, y2-1);
p->setPen(sunken ? cg.mid() : cg.light());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+2, x+1, y2-2);
// Get the button bounding box
TQRect ar = TQStyle::visualRect(
querySubControlMetrics(CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow, TQStyleOption::Default, widget),
ceData, elementFlags );
// Are we enabled?
if ( widget->isEnabled() )
flags |= Style_Enabled;
// Are we "pushed" ?
if ( active & Style_Sunken )
flags |= Style_Sunken;
drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, ar, cg, flags);
}
// Draw an edit field if required
if ( controls & SC_ComboBoxEditField )
{
const TQComboBox * cb = (const TQComboBox *) widget;
TQRect re = TQStyle::visualRect(
querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
SC_ComboBoxEditField, TQStyleOption::Default, widget), ceData, elementFlags );
// Draw the indent
if (cb->editable()) {
p->setPen( cg.dark() );
p->drawLine( re.x(), re.y()-1, re.x()+re.width(), re.y()-1 );
p->drawLine( re.x()-1, re.y(), re.x()-1, re.y()+re.height() );
}
if ( cb->hasFocus() ) {
p->setPen( cg.highlightedText() );
p->setBackgroundColor( cg.highlight() );
} else {
p->setPen( cg.text() );
p->setBackgroundColor( cg.button() );
}
if ( cb->hasFocus() && !cb->editable() ) {
// Draw the contents
p->fillRect( re.x(), re.y(), re.width(), re.height(),
cg.brush( TQColorGroup::Highlight ) );
TQRect re = TQStyle::visualRect(
subRect(SR_ComboBoxFocusRect, ceData, elementFlags, cb), ceData, elementFlags);
drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg,
Style_FocusAtBorder, TQStyleOption(cg.highlight()));
}
}
break;
}
// TOOLBUTTON
// -------------------------------------------------------------------
case CC_ToolButton: {
const TQToolButton *toolbutton = (const TQToolButton *) widget;
TQRect button, menuarea;
button = querySubControlMetrics(control, ceData, elementFlags, SC_ToolButton, opt, widget);
menuarea = querySubControlMetrics(control, ceData, elementFlags, SC_ToolButtonMenu, opt, widget);
SFlags bflags = flags,
mflags = flags;
if (active & SC_ToolButton)
bflags |= Style_Down;
if (active & SC_ToolButtonMenu)
mflags |= Style_Down;
if (controls & SC_ToolButton)
{
// If we're pressed, on, or raised...
if (bflags & (Style_Down | Style_On | Style_Raised))
drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, button, cg, bflags, opt);
// Check whether to draw a background pixmap
else if ( toolbutton->parentWidget() &&
toolbutton->parentWidget()->backgroundPixmap() &&
!toolbutton->parentWidget()->backgroundPixmap()->isNull() )
{
TQPixmap pixmap = *(toolbutton->parentWidget()->backgroundPixmap());
p->drawTiledPixmap( r, pixmap, toolbutton->pos() );
}
else if (widget->parent())
{
if (widget->parent()->inherits(TQTOOLBAR_OBJECT_NAME_STRING))
{
TQToolBar* parent = (TQToolBar*)widget->parent();
TQRect pr = parent->rect();
renderGradient( p, r, cg.button(),
parent->orientation() == Qt::Vertical,
r.x(), r.y(), pr.width()-2, pr.height()-2);
}
else if (widget->parent()->inherits("TQToolBarExtensionWidget"))
{
TQWidget* parent = (TQWidget*)widget->parent();
TQToolBar* toolbar = (TQToolBar*)parent->parent();
TQRect tr = toolbar->rect();
if ( toolbar->orientation() == Qt::Horizontal ) {
renderGradient( p, r, cg.button(), false, r.x(), r.y(),
r.width(), tr.height() );
} else {
renderGradient( p, r, cg.button(), true, r.x(), r.y(),
tr.width(), r.height() );
}
}
}
}
// Draw a toolbutton menu indicator if required
if (controls & SC_ToolButtonMenu)
{
if (mflags & (Style_Down | Style_On | Style_Raised))
drawPrimitive(PE_ButtonDropDown, p, ceData, elementFlags, menuarea, cg, mflags, opt);
drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, menuarea, cg, mflags, opt);
}
if (toolbutton->hasFocus() && !toolbutton->focusProxy()) {
TQRect fr = toolbutton->rect();
fr.addCoords(3, 3, -3, -3);
drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg);
}
break;
}
default:
KStyle::drawComplexControl(control, p, ceData, elementFlags,
r, cg, flags, controls, active, opt, widget);
break;
}
}
void StyleCheckStyle::drawComplexControlMask( ComplexControl control,
TQPainter *p,
const TQStyleControlElementData ceData,
const ControlElementFlags elementFlags,
const TQRect &r,
const TQStyleOption& opt,
const TQWidget *widget ) const
{
switch (control)
{
// COMBOBOX & TOOLBUTTON MASKS
// -------------------------------------------------------------------
case CC_ComboBox:
case CC_ToolButton: {
int x1, y1, x2, y2;
r.coords( &x1, &y1, &x2, &y2 );
TQCOORD corners[] = { x1,y1, x2,y1, x1,y2, x2,y2 };
p->fillRect( r, color1 );
p->setPen( color0 );
p->drawPoints( TQPointArray(4, corners) );
break;
}
default:
KStyle::drawComplexControlMask(control, p, ceData, elementFlags, r, opt, widget);
}
}
TQRect StyleCheckStyle::subRect(SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const
{
// We want the focus rect for buttons to be adjusted from
// the TQt3 defaults to be similar to TQt 2's defaults.
// -------------------------------------------------------------------
if (r == SR_PushButtonFocusRect ) {
const TQPushButton* button = (const TQPushButton*) widget;
TQRect wrect(widget->rect());
int dbw1 = 0, dbw2 = 0;
if (button->isDefault() || button->autoDefault()) {
dbw1 = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
dbw2 = dbw1 * 2;
}
int dfw1 = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2,
dfw2 = dfw1 * 2;
return TQRect(wrect.x() + dfw1 + dbw1 + 1,
wrect.y() + dfw1 + dbw1 + 1,
wrect.width() - dfw2 - dbw2 - 1,
wrect.height() - dfw2 - dbw2 - 1);
} else
return KStyle::subRect(r, ceData, elementFlags, widget);
}
int StyleCheckStyle::pixelMetric(PixelMetric m, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
{
switch(m)
{
// BUTTONS
// -------------------------------------------------------------------
case PM_ButtonMargin: // Space btw. frame and label
return 4;
case PM_ButtonDefaultIndicator: {
return 3;
}
case PM_MenuButtonIndicator: { // Arrow width
return 8;
}
// CHECKBOXES / RADIO BUTTONS
// -------------------------------------------------------------------
case PM_ExclusiveIndicatorWidth: // Radiobutton size
case PM_ExclusiveIndicatorHeight:
case PM_IndicatorWidth: // Checkbox size
case PM_IndicatorHeight: {
return 13; // 13x13
}
default:
return KStyle::pixelMetric(m, ceData, elementFlags, widget);
}
}
TQSize StyleCheckStyle::sizeFromContents( ContentsType contents,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQSize &contentSize,
const TQStyleOption& opt,
const TQWidget* widget ) const
{
switch (contents)
{
// PUSHBUTTON SIZE
// ------------------------------------------------------------------
case CT_PushButton: {
const TQPushButton* button = (const TQPushButton*) widget;
int w = contentSize.width();
int h = contentSize.height();
int bm = pixelMetric( PM_ButtonMargin, ceData, elementFlags, widget );
int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget ) * 2;
w += bm + fw + 6; // ### Add 6 to make way for bold font.
h += bm + fw;
// Ensure we stick to standard width and heights.
if ( button->isDefault() || button->autoDefault() ) {
if ( w < 80 && !button->pixmap() )
w = 80;
// Compensate for default indicator
int di = pixelMetric( PM_ButtonDefaultIndicator, ceData, elementFlags );
w += di * 2;
h += di * 2;
}
if ( h < 22 )
h = 22;
return TQSize( w, h );
}
// POPUPMENU ITEM SIZE
// -----------------------------------------------------------------
case CT_PopupMenuItem: {
if ( ! widget || opt.isDefault() )
return contentSize;
const TQPopupMenu *popup = (const TQPopupMenu *) widget;
bool checkable = popup->isCheckable();
TQMenuItem *mi = opt.menuItem();
int maxpmw = opt.maxIconWidth();
int w = contentSize.width(), h = contentSize.height();
if ( mi->custom() ) {
w = mi->custom()->sizeHint().width();
h = mi->custom()->sizeHint().height();
if ( ! mi->custom()->fullSpan() )
h += 2*itemVMargin + 2*itemFrame;
}
else if ( mi->widget() ) {
} else if ( mi->isSeparator() ) {
w = 10; // Arbitrary
h = 2;
}
else {
if ( mi->pixmap() )
h = TQMAX( h, mi->pixmap()->height() + 2*itemFrame );
else {
// Ensure that the minimum height for text-only menu items
// is the same as the icon size used by KDE.
h = TQMAX( h, 16 + 2*itemFrame );
h = TQMAX( h, popup->fontMetrics().height()
+ 2*itemVMargin + 2*itemFrame );
}
if ( mi->iconSet() )
h = TQMAX( h, mi->iconSet()->pixmap(
TQIconSet::Small, TQIconSet::Normal).height() +
2 * itemFrame );
}
if ( ! mi->text().isNull() && mi->text().find('\t') >= 0 )
w += 12;
else if ( mi->popup() )
w += 2 * arrowHMargin;
if ( maxpmw )
w += maxpmw + 6;
if ( checkable && maxpmw < 20 )
w += 20 - maxpmw;
if ( checkable || maxpmw > 0 )
w += 12;
w += rightBorder;
return TQSize( w, h );
}
default:
return KStyle::sizeFromContents( contents, ceData, elementFlags, contentSize, opt, widget );
}
}
// Fix TQt's wacky image alignment
TQPixmap StyleCheckStyle::stylePixmap(StylePixmap stylepixmap,
TQStyleControlElementData ceData,
ControlElementFlags elementFlags,
const TQStyleOption& opt,
const TQWidget* widget) const
{
switch (stylepixmap) {
case SP_TitleBarMinButton:
return TQPixmap((const char **)hc_minimize_xpm);
case SP_TitleBarCloseButton:
return TQPixmap((const char **)hc_close_xpm);
default:
break;
}
return KStyle::stylePixmap(stylepixmap, ceData, elementFlags, opt, widget);
}
bool StyleCheckStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *event )
{
if (KStyle::objectEventHandler( ceData, elementFlags, source, event ))
return true;
if (ceData.widgetObjectTypes.contains(TQOBJECT_OBJECT_NAME_STRING)) {
TQObject* object = reinterpret_cast<TQObject*>(source);
// Handle push button hover effects.
TQPushButton* button = dynamic_cast<TQPushButton*>(object);
if ( button )
{
if ( (event->type() == TQEvent::Enter) &&
(button->isEnabled()) ) {
hoverWidget = button;
button->repaint( false );
}
else if ( (event->type() == TQEvent::Leave) &&
(TQT_BASE_OBJECT(object) == TQT_BASE_OBJECT(hoverWidget)) ) {
hoverWidget = 0L;
button->repaint( false );
}
}
if ( event->type() == TQEvent::Paint && object->inherits(TQLABEL_OBJECT_NAME_STRING) )
{
TQLabel* lb = static_cast<TQLabel*>(TQT_TQWIDGET(object));
if (lb->pixmap() || lb->picture() || lb->movie() || (lb->textFormat() == TQt::RichText) ||
(lb->textFormat() == TQt::AutoText && TQStyleSheet::mightBeRichText(lb->text())) )
{
return false;
}
TQPainter p(lb);
TQRect cr = lb->contentsRect();
int m = lb->indent();
if ( m < 0 && lb->frameWidth() ) // no indent, but we do have a frame
m = lb->fontMetrics().width('x') / 2 - lb->margin();
if ( m > 0 )
{
int hAlign = TQApplication::horizontalAlignment( lb->alignment() );
if ( hAlign & AlignLeft )
cr.setLeft( cr.left() + m );
if ( hAlign & AlignRight )
cr.setRight( cr.right() - m );
if ( lb->alignment() & AlignTop )
cr.setTop( cr.top() + m );
if ( lb->alignment() & AlignBottom )
cr.setBottom( cr.bottom() - m );
}
TQValueVector<StyleGuideViolation> violations;
if (TQCString(lb->name()) == "KJanusWidgetTitleLabel" || lb->font().bold())
{
// We're a page title
violations = checkTitleStyle(lb->text(), LongTitle, lb->buddy() ? HasAccels : NoAccels);
}
else
{
// We're probably, maybe, not a page title label
// Further checks might be needed, depending on how often this comes up in the wild
violations = checkSentenceStyle(lb->text(), lb->buddy() ? BuddiedWidget: BuddylessWidget, lb->buddy() ? HasAccels : NoAccels);
}
if (lb->buddy())
{
renderViolations(violations, &p, cr,lb->alignment() | ShowPrefix, lb->text() );
// ordinary text or pixmap label
drawItem( &p, cr, lb->alignment(), lb->colorGroup(), lb->isEnabled(),
0, removedXX(stripAccelViolations(lb->text())) );
}
else
{
renderViolations(violations, &p, cr,lb->alignment(), lb->text() );
// ordinary text or pixmap label
drawItem( &p, cr, lb->alignment(), lb->colorGroup(), lb->isEnabled(),
0, removedXX(stripAccelViolations(lb->text())) );
}
p.end();
return true;
}
if ( event->type() == TQEvent::Paint && object->inherits(TQGROUPBOX_OBJECT_NAME_STRING) )
{
TQPaintEvent * pevent = TQT_TQPAINTEVENT(event);
TQGroupBox* gb = static_cast<TQGroupBox*>(TQT_TQWIDGET(object));
bool nestedGroupBox = false;
TQString stripped_title = removedXX(stripAccelViolations(gb->title()));
//Walk parent hierarchy to check whether any are groupboxes too..
TQObject* parent = TQT_TQOBJECT(gb);
// GCC suggested parentheses around assignment used as truth value
// I suggested that it could eat me. GCC won.
while ( (parent = parent->parent()) )
{
if (parent->inherits(TQGROUPBOX_OBJECT_NAME_STRING))
{
nestedGroupBox = true;
break;
}
}
TQPainter paint( gb );
if ( stripped_title.length() )
{
// draw title
TQFontMetrics fm = paint.fontMetrics();
int h = fm.height();
int tw = fm.width( stripped_title, stripped_title.length() ) + 2*fm.width(TQChar(' '));
int x;
if ( gb->alignment() & AlignHCenter ) // center alignment
x = gb->frameRect().width()/2 - tw/2;
else if ( gb->alignment() & AlignRight ) // right alignment
x = gb->frameRect().width() - tw - 8;
else if ( gb->alignment() & AlignLeft ) // left alignment
x = 8;
else
{ // auto align
if( TQApplication::reverseLayout() )
x = gb->frameRect().width() - tw - 8;
else
x = 8;
}
TQRect r( x, 0, tw, h );
TQValueVector<StyleGuideViolation> violations = checkTitleStyle( gb->title(), ShortTitle, HasAccels );
renderViolations( violations, &paint, r, AlignCenter | ShowPrefix, gb->title() );
drawItem(&paint, r, AlignCenter | ShowPrefix, gb->colorGroup(),
gb->isEnabled(), 0, stripped_title );
paint.setClipRegion( pevent->region().subtract( r ) );
}
if (nestedGroupBox)
{
paint.save();
TQPen errorPen(TQt::red, 4, TQPen::DashDotDotLine);
paint.setPen(errorPen);
paint.drawRect( gb->frameRect() );
paint.restore();
}
else
{
drawPrimitive( TQStyle::PE_GroupBoxFrame, &paint, ceData, elementFlags, gb->frameRect(),
gb->colorGroup(), TQStyle::Style_Default,
TQStyleOption(gb->lineWidth(), gb->midLineWidth(),
gb->frameShape(), gb->frameShadow()) );
}
return true; //We already drew the everything
}
}
return false;
}
void StyleCheckStyle::renderGradient( TQPainter* p, const TQRect& r,
TQColor clr, bool, int, int, int, int) const
{
p->fillRect(r, clr);
return;
}
// vim: set noet ts=4 sw=4:
// kate: indent-width 4; replace-tabs off; tab-width 4; space-indent off;
View Git Blame Copy Permalink