summaryrefslogtreecommitdiff
path: root/library
Side-by-side diff
Diffstat (limited to 'library') (more/less context) (ignore whitespace changes)
-rw-r--r--library/datebookmonth.cpp28
-rw-r--r--library/fileselector.cpp16
-rw-r--r--library/finddialog.cpp12
-rw-r--r--library/findwidget_p.cpp4
-rw-r--r--library/ir.cpp4
-rw-r--r--library/network.cpp4
-rw-r--r--library/qcopenvelope_qws.cpp4
-rw-r--r--library/qpeapplication.cpp12
-rw-r--r--library/qpedialog.cpp4
-rw-r--r--library/storage.cpp4
-rw-r--r--library/timestring.cpp2
-rw-r--r--library/tzselect.cpp8
12 files changed, 49 insertions, 53 deletions
diff --git a/library/datebookmonth.cpp b/library/datebookmonth.cpp
index 76e022f..421559e 100644
--- a/library/datebookmonth.cpp
+++ b/library/datebookmonth.cpp
@@ -1,762 +1,762 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "config.h"
#include "datebookmonth.h"
#include "datebookdb.h"
#include "resource.h"
#include <qpe/qpeapplication.h>
#include <qtoolbutton.h>
#include <qspinbox.h>
#include <qcombobox.h>
#include <qvaluestack.h>
#include <qwhatsthis.h>
DateBookMonthHeader::DateBookMonthHeader( QWidget *parent, const char *name )
: QHBox( parent, name )
{
setBackgroundMode( PaletteButton );
begin = new QToolButton( this );
begin->setFocusPolicy(NoFocus);
begin->setPixmap( Resource::loadPixmap( "start" ) );
begin->setAutoRaise( TRUE );
begin->setFixedSize( begin->sizeHint() );
QWhatsThis::add( begin, tr("Show January in the selected year") );
back = new QToolButton( this );
back->setFocusPolicy(NoFocus);
back->setPixmap( Resource::loadPixmap( "back" ) );
back->setAutoRaise( TRUE );
back->setFixedSize( back->sizeHint() );
QWhatsThis::add( back, tr("Show the previous month") );
month = new QComboBox( FALSE, this );
for ( int i = 0; i < 12; ++i )
month->insertItem( Calendar::nameOfMonth( i + 1 ) );
year = new QSpinBox( 1752, 8000, 1, this );
next = new QToolButton( this );
next->setFocusPolicy(NoFocus);
next->setPixmap( Resource::loadPixmap( "forward" ) );
next->setAutoRaise( TRUE );
next->setFixedSize( next->sizeHint() );
QWhatsThis::add( next, tr("Show the next month") );
end = new QToolButton( this );
end->setFocusPolicy(NoFocus);
end->setPixmap( Resource::loadPixmap( "finish" ) );
end->setAutoRaise( TRUE );
end->setFixedSize( end->sizeHint() );
QWhatsThis::add( end, tr("Show December in the selected year") );
- connect( month, SIGNAL( activated( int ) ),
+ connect( month, SIGNAL( activated(int) ),
this, SLOT( updateDate() ) );
- connect( year, SIGNAL( valueChanged( int ) ),
+ connect( year, SIGNAL( valueChanged(int) ),
this, SLOT( updateDate() ) );
connect( begin, SIGNAL( clicked() ),
this, SLOT( firstMonth() ) );
connect( end, SIGNAL( clicked() ),
this, SLOT( lastMonth() ) );
connect( back, SIGNAL( clicked() ),
this, SLOT( monthBack() ) );
connect( next, SIGNAL( clicked() ),
this, SLOT( monthForward() ) );
back->setAutoRepeat( TRUE );
next->setAutoRepeat( TRUE );
}
DateBookMonthHeader::~DateBookMonthHeader()
{
}
void DateBookMonthHeader::updateDate()
{
emit dateChanged( year->value(), month->currentItem() + 1 );
}
void DateBookMonthHeader::firstMonth()
{
emit dateChanged( year->value(), 1 );
month->setCurrentItem( 0 );
}
void DateBookMonthHeader::lastMonth()
{
emit dateChanged( year->value(), 12 );
month->setCurrentItem( 11 );
}
void DateBookMonthHeader::monthBack()
{
if ( month->currentItem() > 0 ) {
emit dateChanged( year->value(), month->currentItem() );
month->setCurrentItem( month->currentItem() - 1 );
} else {
emit dateChanged( year->value() - 1, 12 );
// we have a signal set to a changed value in year so we only need to change
// year to get the result...
month->setCurrentItem( 11 );
year->setValue( year->value() - 1 );
}
}
void DateBookMonthHeader::monthForward()
{
if ( month->currentItem() < 11 ) {
emit dateChanged( year->value(), month->currentItem() + 2 );
month->setCurrentItem( month->currentItem() + 1 );
} else {
// we have a signal set to a changed value in year so we only need to change
// year to get the result...
month->setCurrentItem( 0 );
year->setValue( year->value() + 1 );
}
}
void DateBookMonthHeader::setDate( int y, int m )
{
year->setValue( y );
month->setCurrentItem( m - 1 );
}
//---------------------------------------------------------------------------
class DateBookMonthTablePrivate
{
public:
DateBookMonthTablePrivate() {};
~DateBookMonthTablePrivate() { mMonthEvents.clear(); };
QValueList<EffectiveEvent> mMonthEvents;
bool onMonday;
};
DateBookMonthTable::DateBookMonthTable( QWidget *parent, const char *name,
DateBookDB *newDb )
: QTable( 6, 7, parent, name ),
db( newDb )
{
d = new DateBookMonthTablePrivate();
selYear = -1;
selMonth = -1;
selDay = -1;
/* init these as well make valgrind happy and be consistent with Qtopia1.6 -zecke */
year = -1;
month = -1;
day = -1;
Config cfg( "qpe" );
cfg.setGroup( "Time" );
d->onMonday = cfg.readBoolEntry( "MONDAY" );
horizontalHeader()->setResizeEnabled( FALSE );
// we have to do this here... or suffer the consequences later...
for ( int i = 0; i < 7; i++ ){
horizontalHeader()->resizeSection( i, 30 );
setColumnStretchable( i, TRUE );
}
setupLabels();
verticalHeader()->hide();
setLeftMargin( 0 );
for ( int i = 0; i < 6; ++i )
setRowStretchable( i, TRUE );
setSelectionMode( NoSelection );
- connect( this, SIGNAL( clicked( int, int, int, const QPoint & ) ),
- this, SLOT( dayClicked( int, int ) ) );
- connect( this, SIGNAL( currentChanged( int, int ) ),
- this, SLOT( dragDay( int, int ) ) );
+ connect( this, SIGNAL( clicked(int,int,int,const QPoint&) ),
+ this, SLOT( dayClicked(int,int) ) );
+ connect( this, SIGNAL( currentChanged(int,int) ),
+ this, SLOT( dragDay(int,int) ) );
setVScrollBarMode( AlwaysOff );
setHScrollBarMode( AlwaysOff );
}
DateBookMonthTable::~DateBookMonthTable()
{
monthsEvents.clear();
delete d;
}
void DateBookMonthTable::setDate(int y, int m, int d)
{
if (month == m && year == y) {
if ( selYear == -1 )
year = selYear;
if ( selMonth == -1 )
month = selMonth;
int r1, c1, r2, c2;
findDay(selDay, r1, c1);
selDay = day = d;
findDay(selDay, r2, c2);
setCurrentCell( r2, c2 );
//updateCell(r1,c1);
//updateCell(r2,c2);
} else {
selYear = year = y;
selMonth = month = m;
selDay = day = d;
setupTable();
}
}
void DateBookMonthTable::redraw()
{
setupLabels();
setupTable();
}
void DateBookMonthTable::setWeekStart( bool onMonday )
{
d->onMonday = onMonday;
setupLabels();
setupTable();
}
void DateBookMonthTable::setupTable()
{
QValueList<Calendar::Day> days = Calendar::daysOfMonth( year, month, d->onMonday );
QValueList<Calendar::Day>::Iterator it = days.begin();
int row = 0, col = 0;
int crow = 0;
int ccol = 0;
for ( ; it != days.end(); ++it ) {
DayItemMonth *i = (DayItemMonth *)item( row, col );
if ( !i ) {
i = new DayItemMonth( this, QTableItem::Never, "" );
setItem( row, col, i );
}
Calendar::Day calDay = *it;
i->clearEffEvents();
i->setDay( calDay.date );
i->setType( calDay.type );
if ( i->day() == day && calDay.type == Calendar::Day::ThisMonth ) {
crow = row;
ccol = col;
}
updateCell( row, col );
if ( col == 6 ) {
++row;
col = 0;
} else {
++col;
}
}
setCurrentCell( crow, ccol );
getEvents();
}
void DateBookMonthTable::findDay( int day, int &row, int &col )
{
QDate dtBegin( year, month, 1 );
int skips = dtBegin.dayOfWeek();
int effective_day = day + skips - 1; // row/columns begin at 0
// make an extra adjustment if we start on Mondays.
if ( d->onMonday )
effective_day--;
row = effective_day / 7;
col = effective_day % 7;
}
void DateBookMonthTable::dayClicked( int row, int col )
{
changeDaySelection( row, col );
emit dateClicked( selYear, selMonth, selDay );
}
void DateBookMonthTable::dragDay( int row, int col )
{
changeDaySelection( row, col );
}
void DateBookMonthTable::changeDaySelection( int row, int col )
{
DayItemMonth *i = (DayItemMonth*)item( row, col );
if ( !i )
return;
switch ( i->type() ) {
case Calendar::Day::ThisMonth:
selMonth = month;
break;
case Calendar::Day::PrevMonth:
selMonth = month-1;
break;
default:
selMonth = month+1;
}
selYear = year;
if ( selMonth <= 0 ) {
selMonth = 12;
selYear--;
} else if ( selMonth > 12 ) {
selMonth = 1;
selYear++;
}
selDay = i->day();
}
void DateBookMonthTable::viewportMouseReleaseEvent( QMouseEvent * )
{
dayClicked( currentRow(), currentColumn() );
}
void DateBookMonthTable::getEvents()
{
if ( !db )
return;
QDate dtStart( year, month, 1 );
d->mMonthEvents = db->getEffectiveEvents( dtStart,
QDate( year, month,
dtStart.daysInMonth() ) );
QValueListIterator<EffectiveEvent> it = d->mMonthEvents.begin();
// now that the events are sorted, basically go through the list, make
// a small list for every day and set it for each item...
// clear all the items...
while ( it != d->mMonthEvents.end() ) {
QValueList<EffectiveEvent> dayEvent;
EffectiveEvent e = *it;
++it;
dayEvent.append( e );
while ( it != d->mMonthEvents.end()
&& e.date() == (*it).date() ) {
dayEvent.append( *it );
++it;
}
int row, col;
findDay( e.date().day(), row, col );
DayItemMonth* w = static_cast<DayItemMonth*>( item( row, col ) );
w->setEvents( dayEvent );
updateCell( row, col );
dayEvent.clear();
}
}
void DateBookMonthTable::setupLabels()
{
for ( int i = 0; i < 7; ++i ) {
// horizontalHeader()->resizeSection( i, 30 );
// setColumnStretchable( i, TRUE );
if ( d->onMonday )
horizontalHeader()->setLabel( i, Calendar::nameOfDay( i + 1 ) );
else {
if ( i == 0 )
horizontalHeader()->setLabel( i, Calendar::nameOfDay( 7 ) );
else
horizontalHeader()->setLabel( i, Calendar::nameOfDay( i ) );
}
}
}
//---------------------------------------------------------------------------
DateBookMonth::DateBookMonth( QWidget *parent, const char *name, bool ac,
DateBookDB *data )
: QVBox( parent, name ),
autoClose( ac )
{
setFocusPolicy(StrongFocus);
year = QDate::currentDate().year();
month = QDate::currentDate().month();
day = QDate::currentDate().day();
header = new DateBookMonthHeader( this, "DateBookMonthHeader" );
table = new DateBookMonthTable( this, "DateBookMonthTable", data );
header->setDate( year, month );
table->setDate( year, month, QDate::currentDate().day() );
header->setFocusPolicy(NoFocus);
table->setFocusPolicy(NoFocus);
- connect( header, SIGNAL( dateChanged( int, int ) ),
- this, SLOT( setDate( int, int ) ) );
- connect( table, SIGNAL( dateClicked( int, int, int ) ),
- this, SLOT( finalDate(int, int, int) ) );
+ connect( header, SIGNAL( dateChanged(int,int) ),
+ this, SLOT( setDate(int,int) ) );
+ connect( table, SIGNAL( dateClicked(int,int,int) ),
+ this, SLOT( finalDate(int,int,int) ) );
connect( qApp, SIGNAL(weekChanged(bool)), this,
SLOT(slotWeekChange(bool)) );
table->setFocus();
}
DateBookMonth::~DateBookMonth()
{
}
void DateBookMonth::setDate( int y, int m )
{
/* only change the date if this is a different date,
* other wise we may mistakenly overide the day */
if ( (y != year) || (m != month) ) {
year = y;
month = m;
QDate nd( y, m, 1 );
if ( nd.daysInMonth() < day )
day = nd.daysInMonth();
table->setDate( year, month, day );
}
}
void DateBookMonth::setDate( int y, int m, int d )
{
header->setDate( y, m);
table->setDate( y, m, d);
year = y;
month = m;
day = d;
}
/* called when we wish to close or pass back the date */
void DateBookMonth::finalDate(int y, int m, int d)
{
setDate( y, m, d );
emit dateClicked(y, m, d);
// emit dateClicked(QDate(y, m, d).toString());
if ( autoClose && parentWidget() )
parentWidget()->close();
}
void DateBookMonth::setDate( QDate d)
{
setDate(d.year(), d.month(), d.day());
}
void DateBookMonth::redraw()
{
table->setDate( year, month, day );
table->redraw();
}
QDate DateBookMonth::selectedDate() const
{
if ( !table )
return QDate::currentDate();
int y, m, d;
table->getDate( y, m, d );
return QDate( y, m, d );
}
void DateBookMonth::slotWeekChange( bool startOnMonday )
{
table->setWeekStart( startOnMonday );
}
void DateBookMonth::keyPressEvent( QKeyEvent *e )
{
switch(e->key()) {
case Key_Up:
setDate(QDate(year, month, day).addDays(-7));
break;
case Key_Down:
setDate(QDate(year, month, day).addDays(7));
break;
case Key_Left:
setDate(QDate(year, month, day).addDays(-1));
break;
case Key_Right:
setDate(QDate(year, month, day).addDays(1));
break;
case Key_Space:
qWarning("space");
emit dateClicked(year, month, day);
if ( autoClose && parentWidget() )
parentWidget()->close();
break;
default:
qWarning("ignore");
e->ignore();
break;
}
}
//---------------------------------------------------------------------------
class DayItemMonthPrivate
{
public:
DayItemMonthPrivate() {};
~DayItemMonthPrivate() { mDayEvents.clear(); };
QValueList<EffectiveEvent> mDayEvents;
};
DayItemMonth::DayItemMonth( QTable *table, EditType et, const QString &t )
: QTableItem( table, et, t )
{
d = new DayItemMonthPrivate();
}
DayItemMonth::~DayItemMonth()
{
daysEvents.clear();
delete d;
}
void DayItemMonth::setEvents( const QValueList<EffectiveEvent> &effEv )
{
d->mDayEvents = effEv;
}
void DayItemMonth::clearEffEvents()
{
d->mDayEvents.clear();
}
void DayItemMonth::paint( QPainter *p, const QColorGroup &cg,
const QRect &cr, bool selected )
{
p->save();
QColorGroup g( cg );
g.setBrush( QColorGroup::Base, back );
g.setColor( QColorGroup::Text, forg );
if ( selected )
p->setPen( g.highlightedText() );
else
p->setPen( g.text() );
QValueStack<int> normalLine;
QValueStack<int> repeatLine;
QValueStack<int> travelLine;
bool normalAllDay = FALSE;
bool repeatAllDay = FALSE;
bool travelAllDay = FALSE;
QValueListIterator<EffectiveEvent> itDays = d->mDayEvents.begin();
for ( ; itDays != d->mDayEvents.end(); ++itDays ) {
int w = cr.width();
Event ev = (*itDays).event();
int f = (*itDays).start().hour(); // assume Effective event
int t = (*itDays).end().hour(); // is truncated.
if (ev.isAllDay()) {
if (!ev.hasRepeat())
normalAllDay = TRUE;
else
repeatAllDay = TRUE;
} else {
int sLine, eLine;
if (f == 0)
sLine = 0;
else if (f < 8 )
sLine = 1;
else if (f >= 17)
sLine = w - 4;
else {
sLine = (f - 8) * (w - 8);
if (sLine)
sLine /= 8;
sLine += 4;
}
if (t == 23)
eLine = w;
else if (t < 8)
eLine = 4;
else if (t >= 17)
eLine = w - 1;
else {
eLine = (t - 8) * (w - 8);
if (eLine)
eLine /= 8;
eLine += 4;
}
if (!ev.hasRepeat()) {
normalLine.push(sLine);
normalLine.push(eLine);
} else {
repeatLine.push(sLine);
repeatLine.push(eLine);
}
}
}
// draw the background
if (normalAllDay || repeatAllDay || travelAllDay) {
p->save();
if (normalAllDay)
if (repeatAllDay) {
p->fillRect( 0, 0, cr.width(), cr.height() / 2,
colorNormalLight );
p->fillRect( 0, cr.height() / 2, cr.width(), cr.height() / 2,
colorRepeatLight );
} else
p->fillRect( 0, 0, cr.width(), cr.height(),
colorNormalLight );
else if (repeatAllDay)
p->fillRect( 0, 0, cr.width(), cr.height(),
colorRepeatLight );
} else {
p->fillRect( 0, 0, cr.width(),
cr.height(), selected
? g.brush( QColorGroup::Highlight )
: g.brush( QColorGroup::Base ) );
}
// The lines
// now for the lines.
int h = 5;
int y = cr.height() / 2 - h;
while(normalLine.count() >= 2) {
int x2 = normalLine.pop();
int x1 = normalLine.pop();
if (x2 < x1 + 2)
x2 = x1 + 2;
p->fillRect(x1, y, x2 - x1, h, colorNormal);
}
y += h;
while(repeatLine.count() >= 2) {
int x2 = repeatLine.pop();
int x1 = repeatLine.pop();
if (x2 < x1 + 2)
x2 = x1 + 2;
p->fillRect(x1, y, x2 - x1, h, colorRepeat);
}
// Finally, draw the number.
QFont f = p->font();
f.setPointSize( ( f.pointSize() / 3 ) * 2 );
p->setFont( f );
QFontMetrics fm( f );
p->drawText( 1, 1 + fm.ascent(), QString::number( day() ) );
p->restore();
}
void DayItemMonth::setType( Calendar::Day::Type t )
{
switch ( t ) {
case Calendar::Day::PrevMonth:
case Calendar::Day::NextMonth:
back = QBrush( QColor( 224, 224, 224 ) );
forg = black;
break;
case Calendar::Day::ThisMonth:
back = QBrush( white );
forg = black;
break;
}
typ = t;
}
DateButton::DateButton( bool longDate, QWidget *parent, const char * name )
:QPushButton( parent, name )
{
longFormat = longDate;
df = DateFormat('/', DateFormat::MonthDayYear, DateFormat::MonthDayYear);
setDate( QDate::currentDate() );
connect(this,SIGNAL(pressed()),this,SLOT(pickDate()));
}
void DateButton::pickDate()
{
static QPopupMenu *m1 = 0;
static DateBookMonth *picker = 0;
if ( !m1 ) {
m1 = new QPopupMenu( this );
picker = new DateBookMonth( m1, 0, TRUE );
m1->insertItem( picker );
- connect( picker, SIGNAL( dateClicked( int, int, int ) ),
- this, SLOT( setDate( int, int, int ) ) );
- connect( picker, SIGNAL( dateClicked( int, int, int ) ),
- this, SIGNAL( dateSelected( int, int, int ) ) );
+ connect( picker, SIGNAL( dateClicked(int,int,int) ),
+ this, SLOT( setDate(int,int,int) ) );
+ connect( picker, SIGNAL( dateClicked(int,int,int) ),
+ this, SIGNAL( dateSelected(int,int,int) ) );
connect( m1, SIGNAL( aboutToHide() ),
this, SLOT( gotHide() ) );
}
picker->slotWeekChange( weekStartsMonday );
picker->setDate( currDate.year(), currDate.month(), currDate.day() );
m1->popup(mapToGlobal(QPoint(0,height())));
picker->setFocus();
}
void DateButton::gotHide()
{
// we have to redo the button...
setDown( false );
}
// void dateSelected( int year, int month, int day );
void DateButton::setWeekStartsMonday( int b )
{
weekStartsMonday = b;
}
void DateButton::setDate( int y, int m, int d )
{
setDate( QDate( y,m,d) );
}
void DateButton::setDate( QDate d )
{
currDate = d;
setText( longFormat ? TimeString::longDateString( d, df ) :
TimeString::shortDate( d, df ) );
}
void DateButton::setDateFormat( DateFormat f )
{
df = f;
setDate( currDate );
}
bool DateButton::customWhatsThis() const
{
return TRUE;
}
// this class is only here for Sharp ROM compatibility
// I have reverse engineered this class and it seems to
// work (only qtmail seems to use it) - sandman
// DO NOT USE IT IN NEW CODE !!
DateBookMonthPopup::DateBookMonthPopup ( QWidget *w )
: QPopupMenu ( w )
{
m_dbm = new DateBookMonth( this, 0, TRUE );
insertItem( m_dbm );
}
diff --git a/library/fileselector.cpp b/library/fileselector.cpp
index 7c29aba..93fb429 100644
--- a/library/fileselector.cpp
+++ b/library/fileselector.cpp
@@ -1,579 +1,579 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
// WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
// have this class.
#define QTOPIA_INTERNAL_FSLP
#include "fileselector.h"
#include "fileselector_p.h"
#include "global.h"
#include "resource.h"
#include "config.h"
#include "storage.h"
#include "qpemenubar.h"
#include <qcopchannel_qws.h>
#include "lnkproperties.h"
#include <qpe/qpeapplication.h>
#include "categorymenu.h"
#include "categoryselect.h"
#include "mimetype.h"
#include <qpe/categories.h>
#include <stdlib.h>
#include <qdir.h>
#include <qwidget.h>
#include <qpopupmenu.h>
#include <qtoolbutton.h>
#include <qpushbutton.h>
#include <qheader.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
class TypeCombo : public QComboBox
{
Q_OBJECT
public:
TypeCombo( QWidget *parent, const char *name=0 )
: QComboBox( parent, name )
{
connect( this, SIGNAL(activated(int)), this, SLOT(selectType(int)) );
}
void reread( DocLnkSet &files, const QString &filter );
signals:
void selected( const QString & );
protected slots:
void selectType( int idx ) {
emit selected( typelist[idx] );
}
protected:
QStringList typelist;
QString prev;
};
void TypeCombo::reread( DocLnkSet &files, const QString &filter )
{
typelist.clear();
QStringList filters = QStringList::split( ';', filter );
int pos = filter.find( '/' );
//### do for each filter
if ( filters.count() == 1 && pos >= 0 && filter[pos+1] != '*' ) {
typelist.append( filter );
clear();
QString minor = filter.mid( pos+1 );
minor[0] = minor[0].upper();
insertItem( tr("%1 files").arg(minor) );
setCurrentItem(0);
setEnabled( FALSE );
return;
}
QListIterator<DocLnk> dit( files.children() );
for ( ; dit.current(); ++dit ) {
if ( !typelist.contains( (*dit)->type() ) )
typelist.append( (*dit)->type() );
}
QStringList types;
QStringList::ConstIterator it;
for (it = typelist.begin(); it!=typelist.end(); ++it) {
QString t = *it;
if ( t.left(12) == "application/" ) {
MimeType mt(t);
const AppLnk* app = mt.application();
if ( app )
t = app->name();
else
t = t.mid(12);
} else {
QString major, minor;
int pos = t.find( '/' );
if ( pos >= 0 ) {
major = t.left( pos );
minor = t.mid( pos+1 );
}
if ( minor.find( "x-" ) == 0 )
minor = minor.mid( 2 );
minor[0] = minor[0].upper();
major[0] = major[0].upper();
if ( filters.count() > 1 )
t = tr("%1 %2", "minor mimetype / major mimetype").arg(minor).arg(major);
else
t = minor;
}
types += tr("%1 files").arg(t);
}
for (it = filters.begin(); it!=filters.end(); ++it) {
typelist.append( *it );
int pos = (*it).find( '/' );
if ( pos >= 0 ) {
QString maj = (*it).left( pos );
maj[0] = maj[0].upper();
types << tr("All %1 files").arg(maj);
}
}
if ( filters.count() > 1 ) {
typelist.append( filter );
types << tr("All files");
}
prev = currentText();
clear();
insertStringList(types);
for (int i=0; i<count(); i++) {
if ( text(i) == prev ) {
setCurrentItem(i);
break;
}
}
if ( prev.isNull() )
setCurrentItem(count()-1);
setEnabled( TRUE );
}
//===========================================================================
FileSelectorItem::FileSelectorItem( QListView *parent, const DocLnk &f )
: QListViewItem( parent ), fl( f )
{
setText( 0, f.name() );
setPixmap( 0, f.pixmap() );
}
FileSelectorItem::~FileSelectorItem()
{
}
FileSelectorView::FileSelectorView( QWidget *parent, const char *name )
: QListView( parent, name )
{
setAllColumnsShowFocus( TRUE );
addColumn( tr( "Name" ) );
header()->hide();
}
FileSelectorView::~FileSelectorView()
{
}
void FileSelectorView::keyPressEvent( QKeyEvent *e )
{
QString txt = e->text();
if (e->key() == Key_Space)
emit returnPressed( currentItem() );
else if ( !txt.isNull() && txt[0] > ' ' && e->key() < 0x1000 )
e->ignore();
else
QListView::keyPressEvent(e);
}
class NewDocItem : public FileSelectorItem
{
public:
NewDocItem( QListView *parent, const DocLnk &f )
: FileSelectorItem( parent, f ) {
setText( 0, QObject::tr("New Document") );
QImage img( Resource::loadImage( "new" ) );
QPixmap pm;
pm = img.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() );
setPixmap( 0, pm );
}
QString key ( int, bool ) const {
return QString("\n");
}
void paintCell( QPainter *p, const QColorGroup &cg, int column, int width, int alignment ) {
QFont oldFont = p->font();
QFont newFont = p->font();
newFont.setWeight( QFont::Bold );
p->setFont( newFont );
FileSelectorItem::paintCell( p, cg, column, width, alignment );
p->setFont( oldFont );
}
int width( const QFontMetrics &fm, const QListView *v, int c ) const {
return FileSelectorItem::width( fm, v, c )*4/3; // allow for bold font
}
};
//===========================================================================
class FileSelectorPrivate
{
public:
TypeCombo *typeCombo;
CategorySelect *catSelect;
QValueList<QRegExp> mimeFilters;
int catId;
bool showNew;
NewDocItem *newDocItem;
DocLnkSet files;
QHBox *toolbar;
};
/*!
\class FileSelector fileselector.h
\brief The FileSelector widget allows the user to select DocLnk objects.
This class presents a file selection dialog to the user. This widget
is usually the first widget seen in a \link docwidget.html
document-oriented application\endlink. The developer will most often
create this widget in combination with a <a
href="../qt/qwidgetstack.html"> QWidgetStack</a> and the appropriate
editor and/or viewer widget for their application. This widget
should be shown first and the user can the select which document
they wish to operate on. Please refer to the implementation of
texteditor for an example of how to tie these classes together.
Use setNewVisible() depending on whether the application can be used
to create new files or not. Use setCloseVisible() depending on
whether the user may leave the dialog without creating or selecting
a document or not. The number of files in the view is available from
fileCount(). To force the view to be updated call reread().
If the user presses the 'New Document' button the newSelected()
signal is emitted. If the user selects an existing file the
fileSelected() signal is emitted. The selected file's \link
doclnk.html DocLnk\endlink is available from the selected()
function. If the file selector is no longer necessary the closeMe()
signal is emitted.
\ingroup qtopiaemb
\sa FileManager
*/
/*!
Constructs a FileSelector with mime filter \a f.
The standard Qt \a parent and \a name parameters are passed to the
parent widget.
If \a newVisible is TRUE, the widget has a button to allow the user
the create "new" documents; this is useful for applications that can
create and edit documents but not suitable for applications that
only provide viewing.
\a closeVisible is deprecated
\sa DocLnkSet::DocLnkSet()
*/
FileSelector::FileSelector( const QString &f, QWidget *parent, const char *name, bool newVisible, bool closeVisible )
: QVBox( parent, name ), filter( f )
{
setMargin( 0 );
setSpacing( 0 );
d = new FileSelectorPrivate();
d->newDocItem = 0;
d->showNew = newVisible;
d->catId = -2; // All files
d->toolbar = new QHBox( this );
d->toolbar->setBackgroundMode( PaletteButton ); // same colour as toolbars
d->toolbar->setSpacing( 0 );
d->toolbar->hide();
QWidget *spacer = new QWidget( d->toolbar );
spacer->setBackgroundMode( PaletteButton );
QToolButton *tb = new QToolButton( d->toolbar );
tb->setPixmap( Resource::loadPixmap( "close" ) );
connect( tb, SIGNAL( clicked() ), this, SIGNAL( closeMe() ) );
buttonClose = tb;
tb->setFixedSize( 18, 20 ); // tb->sizeHint() );
tb->setAutoRaise( TRUE );
QToolTip::add( tb, tr( "Close the File Selector" ) );
QPEMenuToolFocusManager::manager()->addWidget( tb );
view = new FileSelectorView( this, "fileview" );
QPEApplication::setStylusOperation( view->viewport(), QPEApplication::RightOnHold );
- connect( view, SIGNAL( mouseButtonClicked( int, QListViewItem *, const QPoint &, int ) ),
- this, SLOT( fileClicked( int, QListViewItem *, const QPoint &, int ) ) );
- connect( view, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint &, int ) ),
- this, SLOT( filePressed( int, QListViewItem *, const QPoint &, int ) ) );
- connect( view, SIGNAL( returnPressed( QListViewItem * ) ),
- this, SLOT( fileClicked( QListViewItem * ) ) );
+ connect( view, SIGNAL( mouseButtonClicked(int,QListViewItem*,const QPoint&,int) ),
+ this, SLOT( fileClicked(int,QListViewItem*,const QPoint&,int) ) );
+ connect( view, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
+ this, SLOT( filePressed(int,QListViewItem*,const QPoint&,int) ) );
+ connect( view, SIGNAL( returnPressed(QListViewItem*) ),
+ this, SLOT( fileClicked(QListViewItem*) ) );
QHBox *hb = new QHBox( this );
d->typeCombo = new TypeCombo( hb );
connect( d->typeCombo, SIGNAL(selected(const QString&)),
this, SLOT(typeSelected(const QString&)) );
QWhatsThis::add( d->typeCombo, tr("Show documents of this type") );
Categories c;
c.load(categoryFileName());
QArray<int> vl( 0 );
d->catSelect = new CategorySelect( hb );
d->catSelect->setRemoveCategoryEdit( TRUE );
d->catSelect->setCategories( vl, "Document View", tr("Document View") );
d->catSelect->setAllCategories( TRUE );
connect( d->catSelect, SIGNAL(signalSelected(int)), this, SLOT(catSelected(int)) );
QWhatsThis::add( d->catSelect, tr("Show documents in this category") );
setCloseVisible( closeVisible );
QCopChannel *channel = new QCopChannel( "QPE/Card", this );
- connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
- this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
+ connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(cardMessage(const QCString&,const QByteArray&)) );
reread();
updateWhatsThis();
}
/*!
Destroys the widget.
*/
FileSelector::~FileSelector()
{
delete d;
}
/*!
Returns the number of files in the view. If this is zero, an editor
application might bypass the selector and immediately start with
a "new" document.
*/
int FileSelector::fileCount()
{
return d->files.children().count();;
}
/*!
Calling this function is the programmatic equivalent of the user
pressing the "new" button.
\sa newSelected(), closeMe()
*/
void FileSelector::createNew()
{
DocLnk f;
emit newSelected( f );
emit closeMe();
}
void FileSelector::fileClicked( int button, QListViewItem *i, const QPoint &, int )
{
if ( !i )
return;
if ( button == Qt::LeftButton ) {
fileClicked( i );
}
}
void FileSelector::filePressed( int button, QListViewItem *i, const QPoint &, int )
{
if ( !i || i == d->newDocItem )
return;
if ( button == Qt::RightButton ) {
DocLnk l = ((FileSelectorItem *)i)->file();
LnkProperties prop( &l );
prop.showMaximized();
prop.exec();
reread();
}
}
void FileSelector::fileClicked( QListViewItem *i )
{
if ( !i )
return;
if ( i == d->newDocItem ) {
createNew();
} else {
emit fileSelected( ( (FileSelectorItem*)i )->file() );
emit closeMe();
}
}
void FileSelector::typeSelected( const QString &type )
{
d->mimeFilters.clear();
QStringList subFilter = QStringList::split(";", type);
for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++it )
d->mimeFilters.append( QRegExp(*it, FALSE, TRUE) );
updateView();
}
void FileSelector::catSelected( int c )
{
d->catId = c;
updateView();
}
void FileSelector::cardMessage( const QCString &msg, const QByteArray &)
{
if ( msg == "mtabChanged()" )
reread();
}
/*!
Returns the selected \link doclnk.html DocLnk\endlink. The caller is
responsible for deleting the returned value.
*/
const DocLnk *FileSelector::selected()
{
FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
if ( item && item != d->newDocItem )
return new DocLnk( item->file() );
return NULL;
}
/*!
\fn void FileSelector::fileSelected( const DocLnk &f )
This signal is emitted when the user selects a document.
\a f is the document.
*/
/*!
\fn void FileSelector::newSelected( const DocLnk &f )
This signal is emitted when the user selects a "new" document.
\a f is a DocLnk for the document. You will need to set the type
of the document after copying it.
*/
/*!
\fn void FileSelector::closeMe()
This signal is emitted when the user no longer needs to view the widget.
*/
/*!
If \a b is TRUE a "new document" entry is visible; if \a b is FALSE
this entry is not visible and the user is unable to create new
documents from the dialog.
*/
void FileSelector::setNewVisible( bool b )
{
if ( d->showNew != b ) {
d->showNew = b;
updateView();
updateWhatsThis();
}
}
/*!
If \a b is TRUE a "close" or "no document" button is visible; if \a
b is FALSE this button is not visible and the user is unable to
leave the dialog without creating or selecting a document.
This function is deprecated.
*/
void FileSelector::setCloseVisible( bool b )
{
if ( b )
d->toolbar->show();
else
d->toolbar->hide();
}
/*!
*/
void FileSelector::setTypeComboVisible( bool b ) {
if ( b )
d->typeCombo->show();
else
d->typeCombo->hide();
}
/*!
*/
void FileSelector::setCategorySelectVisible( bool b ) {
if ( b )
d->catSelect->show();
else
d->catSelect->hide();
}
/*!
Rereads the list of documents.
*/
void FileSelector::reread()
{
d->files.clear();
Global::findDocuments(&d->files, filter);
d->typeCombo->reread( d->files, filter );
updateView();
}
void FileSelector::updateView()
{
FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
if ( item == d->newDocItem )
item = 0;
QString oldFile;
if ( item )
oldFile = item->file().file();
view->clear();
QListIterator<DocLnk> dit( d->files.children() );
for ( ; dit.current(); ++dit ) {
bool mimeMatch = FALSE;
if ( d->mimeFilters.count() ) {
QValueList<QRegExp>::Iterator it;
for ( it = d->mimeFilters.begin(); it != d->mimeFilters.end(); ++it ) {
if ( (*it).match((*dit)->type()) >= 0 ) {
mimeMatch = TRUE;
break;
}
}
} else {
mimeMatch = TRUE;
}
if ( mimeMatch &&
(d->catId == -2 || (*dit)->categories().contains(d->catId) ||
(d->catId == -1 && (*dit)->categories().isEmpty())) ) {
item = new FileSelectorItem( view, **dit );
if ( item->file().file() == oldFile )
view->setCurrentItem( item );
}
}
if ( d->showNew )
d->newDocItem = new NewDocItem( view, DocLnk() );
else
d->newDocItem = 0;
if ( !view->selectedItem() || view->childCount() == 1 ) {
view->setCurrentItem( view->firstChild() );
view->setSelected( view->firstChild(), TRUE );
}
}
void FileSelector::updateWhatsThis()
{
QWhatsThis::remove( this );
QString text = tr("Click to select a document from the list");
if ( d->showNew )
text += tr(", or select <b>New Document</b> to create a new document.");
text += tr("<br><br>Click and hold for document properties.");
QWhatsThis::add( this, text );
}
#include "fileselector.moc"
diff --git a/library/finddialog.cpp b/library/finddialog.cpp
index 64487c9..9417179 100644
--- a/library/finddialog.cpp
+++ b/library/finddialog.cpp
@@ -1,84 +1,80 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
// WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
// have this class.
#define QTOPIA_INTERNAL_FD
#include "finddialog.h"
#include "findwidget_p.h"
#include <qlayout.h>
/*!
\class FindDialog finddialog.h
\brief A simple FindDialog
A find dialog. FIXME!!!!
*/
FindDialog::FindDialog( const QString &appName, QWidget *parent,
const char *name, bool modal )
: QDialog( parent, name, modal )
{
setCaption( tr("Find") );
QVBoxLayout *vb;
vb = new QVBoxLayout( this );
fw = new FindWidget( appName, this, "Find Widget" );
vb->addWidget( fw );
- QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,
- bool,bool,int)),
- this, SIGNAL(signalFindClicked(const QString&,
- bool,bool,int)) );
- QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,const QDate&,
- bool,bool,int)),
- this, SIGNAL(signalFindClicked(const QString&,
- const QDate&,bool,bool,int)) );
+ QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,bool,bool,int)),
+ this, SIGNAL(signalFindClicked(const QString&,bool,bool,int)) );
+ QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,const QDate&,bool,bool,int)),
+ this, SIGNAL(signalFindClicked(const QString&,const QDate&,bool,bool,int)) );
d = 0;
}
FindDialog::~FindDialog()
{
}
QString FindDialog::findText() const
{
return fw->findText();
}
void FindDialog::setUseDate( bool show )
{
fw->setUseDate( show );
}
void FindDialog::setDate( const QDate &dt )
{
fw->setDate( dt );
}
void FindDialog::slotNotFound()
{
fw->slotNotFound();
}
void FindDialog::slotWrapAround()
{
fw->slotWrapAround();
}
diff --git a/library/findwidget_p.cpp b/library/findwidget_p.cpp
index e91d789..0591f07 100644
--- a/library/findwidget_p.cpp
+++ b/library/findwidget_p.cpp
@@ -1,114 +1,114 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "findwidget_p.h"
#include <qpe/categoryselect.h>
#include <qpe/datebookmonth.h>
#include <qcheckbox.h>
#include <qlabel.h>
#include <qlineedit.h>
FindWidget::FindWidget( const QString &appName, QWidget *parent,
const char *name )
: FindWidgetBase( parent, name ),
mStrApp( appName ),
mDate( QDate::currentDate() )
{
setMaximumSize( sizeHint() );
QArray<int> vl(0);
cmbCat->setCategories( vl, mStrApp );
cmbCat->setRemoveCategoryEdit( TRUE );
cmbCat->setAllCategories( TRUE );
// hide junk for the moment...
lblStartDate->hide();
cmdStartDate->hide();
QPopupMenu *m1 = new QPopupMenu( this );
dtPicker = new DateBookMonth( m1, 0, TRUE );
dtPicker->setDate( mDate.year(), mDate.month(), mDate.day() );
m1->insertItem( dtPicker );
cmdStartDate->setPopup( m1 );
cmdStartDate->setText( TimeString::shortDate(mDate) );
- QObject::connect( dtPicker, SIGNAL(dateClicked(int, int, int)),
- this, SLOT(slotDateChanged(int, int, int)) );
+ QObject::connect( dtPicker, SIGNAL(dateClicked(int,int,int)),
+ this, SLOT(slotDateChanged(int,int,int)) );
QObject::connect( cmdFind, SIGNAL(clicked()),
this, SLOT(slotFindClicked()) );
}
FindWidget::~FindWidget()
{
}
QString FindWidget::findText() const
{
return txtFind->text();
}
void FindWidget::slotFindClicked()
{
lblStatus->setText( "" );
if ( cmdStartDate->isVisible() )
emit signalFindClicked( findText(),
mDate,
chkCase->isChecked(),
chkBackwards->isChecked(),
cmbCat->currentCategory() );
else
emit signalFindClicked( findText(), chkCase->isChecked(),
chkBackwards->isChecked(),
cmbCat->currentCategory() );
}
void FindWidget::setUseDate( bool show )
{
if ( show ) {
lblStartDate->show();
cmdStartDate->show();
} else {
lblStartDate->hide();
cmdStartDate->hide();
}
chkBackwards->setDisabled( show );
}
void FindWidget::setDate( const QDate &dt )
{
slotDateChanged( dt.year(), dt.month(), dt.day() );
}
void FindWidget::slotNotFound()
{
lblStatus->setText( tr("String Not Found.") );
}
void FindWidget::slotWrapAround()
{
lblStatus->setText( tr("End reached, starting at %1", "Date using TimeString::shortDate")
.arg(TimeString::shortDate( mDate ) ) );
}
void FindWidget::slotDateChanged( int year, int month, int day )
{
mDate.setYMD( year, month, day );
cmdStartDate->setText( TimeString::shortDate( mDate ) );
dtPicker->setDate( year, month, day );
}
diff --git a/library/ir.cpp b/library/ir.cpp
index 32c0925..c581eb1 100644
--- a/library/ir.cpp
+++ b/library/ir.cpp
@@ -1,116 +1,116 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "ir.h"
#include "qcopenvelope_qws.h"
#include "applnk.h"
/*!
\class Ir ir.h
\brief The Ir class implements basic support for sending objects over an
infrared communication link.
Both \link doclnk.html DocLnk\endlink objects and files can be
sent to another device via the infrared link using the send()
function. When the send has completed the done() signal is
emitted.
The supported() function returns whether the device supports
infrared communication or not.
\ingroup qtopiaemb
*/
/*!
Constructs an Ir object. The \a parent and \a name classes are the
standard QObject parameters.
*/
Ir::Ir( QObject *parent, const char *name )
: QObject( parent, name )
{
#ifndef QT_NO_COP
ch = new QCopChannel( "QPE/Obex" );
- connect( ch, SIGNAL(received(const QCString &, const QByteArray &)),
- this, SLOT(obexMessage( const QCString &, const QByteArray &)) );
+ connect( ch, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(obexMessage(const QCString&,const QByteArray&)) );
#endif
}
/*!
Returns TRUE if the system supports infrared communication;
otherwise returns FALSE.
*/
bool Ir::supported()
{
#ifndef QT_NO_COP
return QCopChannel::isRegistered( "QPE/Obex" );
#endif
}
/*!
Sends the object in file \a fn over the infrared link. The \a
description is used in the text shown to the user while sending
is in progress. The optional \a mimetype parameter specifies the
mimetype of the object. If this parameter is not set, it is
determined by the the filename's suffix.
\sa done()
*/
void Ir::send( const QString &fn, const QString &description, const QString &mimetype)
{
if ( !filename.isEmpty() ) return;
filename = fn;
#ifndef QT_NO_COP
QCopEnvelope e("QPE/Obex", "send(QString,QString,QString)");
e << description << filename << mimetype;
#endif
}
/*!
\overload
Uses the DocLnk::file() and DocLnk::type() of \a doc.
\sa done()
*/
void Ir::send( const DocLnk &doc, const QString &description )
{
send( doc.file(), description, doc.type() );
}
/*!
\fn Ir::done( Ir *ir );
This signal is emitted by \a ir, when the send comand has been processed.
*/
/*!\internal
*/
void Ir::obexMessage( const QCString &msg, const QByteArray &data)
{
if ( msg == "done(QString)" ) {
QString fn;
QDataStream stream( data, IO_ReadOnly );
stream >> fn;
if ( fn == filename )
emit done( this );
}
}
diff --git a/library/network.cpp b/library/network.cpp
index 991e11a..df28857 100644
--- a/library/network.cpp
+++ b/library/network.cpp
@@ -1,448 +1,448 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#define QTOPIA_INTERNAL_LANGLIST
#include "qpe/network.h"
#include "qpe/networkinterface.h"
#include "qpe/global.h"
#include "qpe/config.h"
#include "qpe/resource.h"
#include "qpe/qpeapplication.h"
#include <qpe/qcopenvelope_qws.h>
#include <qpe/qlibrary.h>
#include <qlistbox.h>
#include <qdir.h>
#include <qlayout.h>
#include <qdict.h>
#include <qtranslator.h>
#include <stdlib.h>
#ifndef QT_NO_COP
class NetworkEmitter : public QCopChannel {
Q_OBJECT
public:
NetworkEmitter() : QCopChannel("QPE/Network",qApp)
{
}
void receive(const QCString &msg, const QByteArray&)
{
if ( msg == "choicesChanged()" )
emit changed();
}
signals:
void changed();
};
/*!
\internal
Requests that the service \a choice be started. The \a password is
the password to use if required.
*/
void Network::start(const QString& choice, const QString& password)
{
QCopEnvelope e("QPE/Network", "start(QString,QString)");
e << choice << password;
}
/*!
\class Network network.h
\brief The Network class provides network access functionality.
\internal
*/
// copy the proxy settings of the active config over to the Proxies.conf file
/*!
\internal
*/
void Network::writeProxySettings( Config &cfg )
{
Config proxy( Network::settingsDir() + "/Proxies.conf", Config::File );
proxy.setGroup("Properties");
cfg.setGroup("Proxy");
proxy.writeEntry("type", cfg.readEntry("type") );
proxy.writeEntry("autoconfig", cfg.readEntry("autoconfig") );
proxy.writeEntry("httphost", cfg.readEntry("httphost") );
proxy.writeEntry("httpport", cfg.readEntry("httpport") );
proxy.writeEntry("ftphost", cfg.readEntry("ftphost") );
proxy.writeEntry("ftpport", cfg.readEntry("ftpport") );
proxy.writeEntry("noproxies", cfg.readEntry("noproxies") );
cfg.setGroup("Properties");
}
/*!
\internal
Stops the current network service.
*/
void Network::stop()
{
QCopEnvelope e("QPE/Network", "stop()");
}
static NetworkEmitter *emitter = 0;
/*!
\internal
*/
void Network::connectChoiceChange(QObject* receiver, const char* slot)
{
if ( !emitter )
emitter = new NetworkEmitter;
QObject::connect(emitter,SIGNAL(changed()),receiver,slot);
}
#endif // QT_NO_COP
/*!
\internal
*/
QString Network::settingsDir()
{
return Global::applicationFileName("Network", "modules");
}
#ifndef QT_NO_COP
/*!
\internal
*/
QStringList Network::choices(QListBox* lb, const QString& dir)
{
QStringList list;
if ( lb )
lb->clear();
QString adir = dir.isEmpty() ? settingsDir() : dir;
QDir settingsdir(adir);
settingsdir.mkdir(adir);
QStringList files = settingsdir.entryList("*.conf");
for (QStringList::ConstIterator it=files.begin(); it!=files.end(); ++it ) {
QString filename = settingsdir.filePath(*it);
Config cfg(filename, Config::File);
cfg.setGroup("Info");
if ( lb )
lb->insertItem(Resource::loadPixmap("Network/" + cfg.readEntry("Type")),
cfg.readEntry("Name"));
list.append(filename);
}
return list;
}
class NetworkServer : public QCopChannel {
Q_OBJECT
public:
NetworkServer(QObject* parent) : QCopChannel("QPE/Network",parent), wait(0)
{
up = FALSE;
examineNetworks( TRUE );
QCopChannel* card = new QCopChannel("QPE/Card",parent);
- connect(card,SIGNAL(received(const QCString &, const QByteArray&)),
- this,SLOT(cardMessage(const QCString &, const QByteArray&)));
+ connect(card,SIGNAL(received(const QCString&,const QByteArray&)),
+ this,SLOT(cardMessage(const QCString&,const QByteArray&)));
}
~NetworkServer()
{
stop();
}
bool networkOnline() const
{
return up;
}
private:
void receive(const QCString &msg, const QByteArray& data)
{
if ( msg == "start(QString,QString)" ) {
QDataStream stream(data,IO_ReadOnly);
QString file,password;
stream >> file >> password;
if ( file.isEmpty() ) {
QStringList l = Network::choices();
for (QStringList::ConstIterator i=l.begin(); i!=l.end(); ++i) {
Config cfg(*i,Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
cfg.setGroup("Properties");
if ( plugin && plugin->isAvailable(cfg) ) {
file = *i;
break;
}
}
if ( file.isEmpty() ) {
QCopEnvelope("QPE/Network", "failed()");
return;
}
}
start(file,password);
} else if ( msg == "stop()" ) {
stop();
} else if ( msg == "choicesChanged()" ) {
examineNetworks();
}
}
private slots:
void cardMessage(const QCString &msg, const QByteArray&)
{
if ( msg == "stabChanged()" )
examineNetworks();
}
private:
void examineNetworks( bool firstStart = FALSE )
{
QStringList l = Network::choices();
bool wasup = up; up=FALSE;
QStringList pavailable = available;
available.clear();
for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
Config cfg(*it,Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
cfg.setGroup("Properties");
if ( plugin ) {
if ( plugin->isActive(cfg) ) {
up = TRUE;
if ( firstStart )
plugin->start( cfg );
}
if ( plugin->isAvailable(cfg) )
available.append(*it);
}
}
// Try to work around unreproducible bug whereby
// the netmon applet shows wrong state.
bool reannounce = wait<0;
if ( available != pavailable || reannounce ) {
QCopEnvelope e("QPE/Network", "available(QStringList)");
e << available;
}
if ( up != wasup || reannounce ) {
QCopEnvelope("QPE/Network", up ? "up()" : "down()");
}
}
void start( const QString& file, const QString& password )
{
if ( !current.isEmpty() )
stop();
current = QString::null;
Config cfg(file, Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
bool started = FALSE;
if ( plugin ) {
cfg.setGroup("Properties");
if ( plugin->start(cfg,password) ) {
Network::writeProxySettings( cfg );
current = file;
wait=0;
startTimer(400);
started = TRUE;
}
}
if ( !started ) {
QCopEnvelope("QPE/Network", "failed()");
}
}
void stop()
{
bool stopped = FALSE;
if ( !current.isEmpty() ) {
Config cfg(current, Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
if ( plugin ) {
cfg.setGroup("Properties");
if ( plugin->stop(cfg) ) {
current = QString::null;
wait=0;
startTimer(400);
stopped = TRUE;
}
}
}
if ( !stopped ) {
QCopEnvelope("QPE/Network", "failed()");
}
}
void timerEvent(QTimerEvent*)
{
examineNetworks();
if ( wait >= 0 ) {
if ( up == !current.isNull() ) {
// done
killTimers();
if ( up ) {
startTimer(3000); // monitor link
wait = -1;
}
} else {
wait++;
if ( wait == 600 ) {
killTimers(); // forget about it after 240 s
QCopEnvelope("QPE/Network", "failed()");
up = !current.isNull();
}
}
} else if ( !up ) {
killTimers();
}
}
private:
QStringList available;
QString current;
bool up;
int wait;
};
static NetworkServer* ns=0;
/*!
\internal
*/
QString Network::serviceName(const QString& service)
{
Config cfg(service, Config::File);
cfg.setGroup("Info");
return cfg.readEntry("Name");
}
/*!
\internal
*/
QString Network::serviceType(const QString& service)
{
Config cfg(service, Config::File);
cfg.setGroup("Info");
return cfg.readEntry("Type");
}
/*!
\internal
*/
bool Network::serviceNeedsPassword(const QString& service)
{
Config cfg(service,Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
cfg.setGroup("Properties");
return plugin ? plugin->needPassword(cfg) : FALSE;
}
/*!
\internal
*/
bool Network::networkOnline()
{
return ns && ns->networkOnline();
}
/*!
\internal
*/
void Network::createServer(QObject* parent)
{
ns = new NetworkServer(parent);
}
/*!
\internal
*/
int Network::addStateWidgets(QWidget* parent)
{
int n=0;
QStringList l = Network::choices();
QVBoxLayout* vb = new QVBoxLayout(parent);
for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
Config cfg(*it,Config::File);
cfg.setGroup("Info");
QString type = cfg.readEntry("Type");
NetworkInterface* plugin = Network::loadPlugin(type);
cfg.setGroup("Properties");
if ( plugin ) {
QWidget* w;
if ( (w=plugin->addStateWidget(parent,cfg)) ) {
n++;
vb->addWidget(w);
}
}
}
return n;
}
static QDict<NetworkInterface> *ifaces;
/*!
\internal
*/
NetworkInterface* Network::loadPlugin(const QString& type)
{
#ifndef QT_NO_COMPONENT
if ( !ifaces ) ifaces = new QDict<NetworkInterface>;
NetworkInterface *iface = ifaces->find(type);
if ( !iface ) {
#ifdef Q_OS_MACX
QString libfile = QPEApplication::qpeDir() + "/plugins/network/lib" + type + ".dylib";
#else
QString libfile = QPEApplication::qpeDir() + "/plugins/network/lib" + type + ".so";
#endif
QLibrary lib(libfile);
if ( !lib.queryInterface( IID_Network, (QUnknownInterface**)&iface ) == QS_OK )
return 0;
ifaces->insert(type,iface);
QStringList langs = Global::languageList();
for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
QString lang = *it;
QTranslator * trans = new QTranslator(qApp);
QString tfn = QPEApplication::qpeDir()+"/i18n/"+lang+"/lib"+type+".qm";
if ( trans->load( tfn ))
qApp->installTranslator( trans );
else
delete trans;
}
}
return iface;
#else
return 0;
#endif
}
#include "network.moc"
#endif // QT_NO_COP
diff --git a/library/qcopenvelope_qws.cpp b/library/qcopenvelope_qws.cpp
index 8f58787..63efb13 100644
--- a/library/qcopenvelope_qws.cpp
+++ b/library/qcopenvelope_qws.cpp
@@ -1,145 +1,145 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#ifndef QT_NO_COP
#include "qcopenvelope_qws.h"
#endif
#include <qbuffer.h>
#include <qfile.h>
#include <unistd.h>
#include <errno.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#ifndef QT_NO_COP
/*!
\class QCopEnvelope qcopenvelope_qws.h
\brief The QCopEnvelope class encapsulates and sends QCop messages
over QCopChannels.
QCop messages allow applications to communicate with each other.
These messages are sent using QCopEnvelope, and received by connecting
to a QCopChannel.
To send a message, use the following protocol:
\code
QCopEnvelope e(channelname, messagename);
e << parameter1 << parameter2 << ...;
\endcode
For messages without parameters, simply use:
\code
QCopEnvelope e(channelname, messagename);
\endcode
(Do not try to simplify this further as it may confuse some
compilers.)
The \c{channelname} of channels within Qtopia all start with "QPE/".
The \c{messagename} is a function identifier followed by a list of types
in parentheses. There is no whitespace in the message name.
To receive a message, you will generally just use your application's
predefined QPE/Application/\e{appname} channel
(see QPEApplication::appMessage()), but you can make another channel
and connect it to a slot like this:
\code
myChannel = new QCopChannel( "QPE/FooBar", this );
- connect( myChannel, SIGNAL(received(const QCString &, const QByteArray &)),
- this, SLOT(fooBarMessage( const QCString &, const QByteArray &)) );
+ connect( myChannel, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(fooBarMessage(const QCString&,const QByteArray&)) );
\endcode
See also, the \link qcop.html list of Qtopia messages\endlink.
*/
/*!
Constructs a QCopEnvelope that will write \a message to \a channel.
If \a message has parameters, you must then use operator<<() to
add these parameters to the envelope.
*/
QCopEnvelope::QCopEnvelope( const QCString& channel, const QCString& message ) :
QDataStream(new QBuffer),
ch(channel), msg(message)
{
device()->open(IO_WriteOnly);
}
/*!
Writes the message and then destroys the QCopEnvelope.
*/
QCopEnvelope::~QCopEnvelope()
{
QByteArray data = ((QBuffer*)device())->buffer();
const int pref=16;
if ( qstrncmp(ch.data(),"QPE/Application/",pref)==0 ) {
QString qcopfn("/tmp/qcop-msg-");
qcopfn += ch.mid(pref);
QFile qcopfile(qcopfn);
if ( qcopfile.open(IO_WriteOnly | IO_Append) ) {
#ifndef Q_OS_WIN32
if(flock(qcopfile.handle(), LOCK_EX)) {
/* some error occurred */
qWarning(QString("Failed to obtain file lock on %1 (%2)")
.arg(qcopfn).arg( errno ));
}
#endif
{
QDataStream ds(&qcopfile);
ds << ch << msg << data;
qcopfile.flush();
#ifndef Q_OS_WIN32
flock(qcopfile.handle(), LOCK_UN);
#endif
qcopfile.close();
}
QByteArray b;
QDataStream stream(b, IO_WriteOnly);
stream << QString(ch.mid(pref));
QCopChannel::send("QPE/Server", "processQCop(QString)", b);
delete device();
return;
} else {
qWarning(QString("Failed to open file %1")
.arg(qcopfn));
} // endif open
}
else if (qstrncmp(ch.data(), "QPE/SOAP/", 9) == 0) {
// If this is a message that should go along the SOAP channel, we move the
// endpoint URL to the data section.
QString endpoint = ch.mid(9);
ch = "QPE/SOAP";
// Since byte arrays are explicitly shared, this is appended to the data variable..
*this << endpoint;
}
QCopChannel::send(ch,msg,data);
delete device();
}
#endif
diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 262221e..c339a78 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -247,893 +247,893 @@ public:
QStringList::Iterator it;
for ( it = list.begin(); it != list.end(); ++it ) {
TextCodecInterface *iface = 0;
QLibrary *lib = new QLibrary( path + "/" + *it );
if ( lib->queryInterface( IID_QtopiaTextCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
QValueList<int> mibs = iface->mibEnums();
for (QValueList<int>::ConstIterator i = mibs.begin(); i != mibs.end(); ++i) {
(void)iface->createForMib(*i);
// ### it exists now; need to remember if we can delete it
}
}
else {
lib->unload();
delete lib;
}
}
}
void loadImageCodecs()
{
QString path = QPEApplication::qpeDir() + "/plugins/imagecodecs";
#ifdef Q_OS_MACX
QDir dir( path, "lib*.dylib" );
#else
QDir dir( path, "lib*.so" );
#endif
QStringList list;
if ( dir. exists ( ))
list = dir.entryList();
QStringList::Iterator it;
for ( it = list.begin(); it != list.end(); ++it ) {
ImageCodecInterface *iface = 0;
QLibrary *lib = new QLibrary( path + "/" + *it );
if ( lib->queryInterface( IID_QtopiaImageCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
QStringList formats = iface->keys();
for (QStringList::ConstIterator i = formats.begin(); i != formats.end(); ++i) {
(void)iface->installIOHandler(*i);
// ### it exists now; need to remember if we can delete it
}
}
else {
lib->unload();
delete lib;
}
}
}
};
class ResourceMimeFactory : public QMimeSourceFactory
{
public:
ResourceMimeFactory() : resImage( 0 )
{
setFilePath( Global::helpPath() );
setExtensionType( "html", "text/html;charset=UTF-8" );
}
~ResourceMimeFactory() {
delete resImage;
}
const QMimeSource* data( const QString& abs_name ) const
{
const QMimeSource * r = QMimeSourceFactory::data( abs_name );
if ( !r ) {
int sl = abs_name.length();
do {
sl = abs_name.findRev( '/', sl - 1 );
QString name = sl >= 0 ? abs_name.mid( sl + 1 ) : abs_name;
int dot = name.findRev( '.' );
if ( dot >= 0 )
name = name.left( dot );
QImage img = Resource::loadImage( name );
if ( !img.isNull() ) {
delete resImage;
resImage = new QImageDrag( img );
r = resImage;
}
}
while ( !r && sl > 0 );
}
return r;
}
private:
mutable QImageDrag *resImage;
};
static int& hack(int& i)
{
#if QT_VERSION <= 230 && defined(QT_NO_CODECS)
// These should be created, but aren't in Qt 2.3.0
(void)new QUtf8Codec;
(void)new QUtf16Codec;
#endif
return i;
}
static int muted = 0;
static int micMuted = 0;
static void setVolume( int t = 0, int percent = -1 )
{
switch ( t ) {
case 0: {
Config cfg( "qpe" );
cfg.setGroup( "Volume" );
if ( percent < 0 )
percent = cfg.readNumEntry( "VolumePercent", 50 );
#ifndef QT_NO_SOUND
int fd = 0;
if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
int vol = muted ? 0 : percent;
// set both channels to same volume
vol |= vol << 8;
ioctl( fd, MIXER_WRITE( 0 ), &vol );
::close( fd );
}
#endif
}
break;
}
}
static void setMic( int t = 0, int percent = -1 )
{
switch ( t ) {
case 0: {
Config cfg( "qpe" );
cfg.setGroup( "Volume" );
if ( percent < 0 )
percent = cfg.readNumEntry( "Mic", 50 );
#ifndef QT_NO_SOUND
int fd = 0;
int mic = micMuted ? 0 : percent;
if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
ioctl( fd, MIXER_WRITE( SOUND_MIXER_MIC ), &mic );
::close( fd );
}
#endif
}
break;
}
}
static void setBass( int t = 0, int percent = -1 )
{
switch ( t ) {
case 0: {
Config cfg( "qpe" );
cfg.setGroup( "Volume" );
if ( percent < 0 )
percent = cfg.readNumEntry( "BassPercent", 50 );
#ifndef QT_NO_SOUND
int fd = 0;
int bass = percent;
if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
ioctl( fd, MIXER_WRITE( SOUND_MIXER_BASS ), &bass );
::close( fd );
}
#endif
}
break;
}
}
static void setTreble( int t = 0, int percent = -1 )
{
switch ( t ) {
case 0: {
Config cfg( "qpe" );
cfg.setGroup( "Volume" );
if ( percent < 0 )
percent = cfg.readNumEntry( "TreblePercent", 50 );
#ifndef QT_NO_SOUND
int fd = 0;
int treble = percent;
if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
ioctl( fd, MIXER_WRITE( SOUND_MIXER_TREBLE ), &treble );
::close( fd );
}
#endif
}
break;
}
}
/**
\class QPEApplication
\brief The QPEApplication class implements various system services
that are available to all Qtopia applications.
Simply by using QPEApplication instead of QApplication, a standard Qt
application becomes a Qtopia application. It automatically follows
style changes, quits and raises, and in the
case of \link docwidget.html document-oriented\endlink applications,
changes the currently displayed document in response to the environment.
To create a \link docwidget.html document-oriented\endlink
application use showMainDocumentWidget(); to create a
non-document-oriented application use showMainWidget(). The
keepRunning() function indicates whether the application will
continue running after it's processed the last \link qcop.html
QCop\endlink message. This can be changed using setKeepRunning().
A variety of signals are emitted when certain events occur, for
example, timeChanged(), clockChanged(), weekChanged(),
dateFormatChanged() and volumeChanged(). If the application receives
a \link qcop.html QCop\endlink message on the application's
QPE/Application/\e{appname} channel, the appMessage() signal is
emitted. There are also flush() and reload() signals, which
are emitted when synching begins and ends respectively - upon these
signals, the application should save and reload any data
files that are involved in synching. Most of these signals will initially
be received and unfiltered through the appMessage() signal.
This class also provides a set of useful static functions. The
qpeDir() and documentDir() functions return the respective paths.
The grabKeyboard() and ungrabKeyboard() functions are used to
control whether the application takes control of the device's
physical buttons (e.g. application launch keys). The stylus' mode of
operation is set with setStylusOperation() and retrieved with
stylusOperation(). There are also setInputMethodHint() and
inputMethodHint() functions.
\ingroup qtopiaemb
*/
/*!
\fn void QPEApplication::clientMoused()
\internal
*/
/*!
\fn void QPEApplication::timeChanged();
This signal is emitted when the time changes outside the normal
passage of time, i.e. if the time is set backwards or forwards.
*/
/*!
\fn void QPEApplication::clockChanged( bool ampm );
This signal is emitted when the user changes the clock's style. If
\a ampm is TRUE, the user wants a 12-hour AM/PM clock, otherwise,
they want a 24-hour clock.
*/
/*!
\fn void QPEApplication::volumeChanged( bool muted )
This signal is emitted whenever the mute state is changed. If \a
muted is TRUE, then sound output has been muted.
*/
/*!
\fn void QPEApplication::weekChanged( bool startOnMonday )
This signal is emitted if the week start day is changed. If \a
startOnMonday is TRUE then the first day of the week is Monday; if
\a startOnMonday is FALSE then the first day of the week is
Sunday.
*/
/*!
\fn void QPEApplication::dateFormatChanged(DateFormat)
This signal is emitted whenever the date format is changed.
*/
/*!
\fn void QPEApplication::flush()
###
*/
/*!
\fn void QPEApplication::reload()
*/
void QPEApplication::processQCopFile()
{
QString qcopfn("/tmp/qcop-msg-");
qcopfn += d->appName; // append command name
QFile f(qcopfn);
if ( f.open(IO_ReadWrite) ) {
#ifndef Q_OS_WIN32
flock(f.handle(), LOCK_EX);
#endif
QDataStream ds(&f);
QCString channel, message;
QByteArray data;
while(!ds.atEnd()) {
ds >> channel >> message >> data;
d->enqueueQCop(channel,message,data);
}
::ftruncate(f.handle(), 0);
#ifndef Q_OS_WIN32
f.flush();
flock(f.handle(), LOCK_UN);
#endif
}
#endif
}
/*!
\fn void QPEApplication::appMessage( const QCString& msg, const QByteArray& data )
This signal is emitted when a message is received on this
application's QPE/Application/<i>appname</i> \link qcop.html
QCop\endlink channel.
The slot to which you connect this signal uses \a msg and \a data
in the following way:
\code
void MyWidget::receive( const QCString& msg, const QByteArray& data )
{
QDataStream stream( data, IO_ReadOnly );
if ( msg == "someMessage(int,int,int)" ) {
int a,b,c;
stream >> a >> b >> c;
...
} else if ( msg == "otherMessage(QString)" ) {
...
}
}
\endcode
\sa qcop.html
Note that messages received here may be processed by qpe application
and emitted as signals, such as flush() and reload().
*/
/*!
Constructs a QPEApplication just as you would construct
a QApplication, passing \a argc, \a argv, and \a t.
For applications, \a t should be the default, GuiClient. Only
the Qtopia server passes GuiServer.
*/
QPEApplication::QPEApplication( int & argc, char **argv, Type t )
: QApplication( hack(argc), argv, t ), pidChannel( 0 )
{
QPixmapCache::setCacheLimit(256); // sensible default for smaller devices.
d = new QPEApplicationData;
d->loadTextCodecs();
d->loadImageCodecs();
int dw = desktop() ->width();
if ( dw < 200 ) {
setFont( QFont( "vera", 8 ) );
AppLnk::setSmallIconSize( 10 );
AppLnk::setBigIconSize( 28 );
}
#if defined(OPIE_HIGH_RES_SMALL_PHY)
else if ( dw > 600 ) {
setFont( QFont( "vera", 16 ) );
AppLnk::setSmallIconSize( 24 );
AppLnk::setBigIconSize( 48 );
}
#endif
else if ( dw > 200 ) {
setFont( QFont( "vera", 10 ) );
AppLnk::setSmallIconSize( 14 );
AppLnk::setBigIconSize( 32 );
}
QMimeSourceFactory::setDefaultFactory( new ResourceMimeFactory );
connect( this, SIGNAL( lastWindowClosed() ), this, SLOT( hideOrQuit() ) );
sysChannel = new QCopChannel( "QPE/System", this );
- connect( sysChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
- this, SLOT( systemMessage( const QCString &, const QByteArray & ) ) );
+ connect( sysChannel, SIGNAL( received(const QCString&,const QByteArray&) ),
+ this, SLOT( systemMessage(const QCString&,const QByteArray&) ) );
/* COde now in initapp */
#if 0
#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
QString qcopfn( "/tmp/qcop-msg-" );
qcopfn += QString( argv[ 0 ] ); // append command name
QFile f( qcopfn );
if ( f.open( IO_ReadOnly ) ) {
flock( f.handle(), LOCK_EX );
}
QCString channel = QCString( argv[ 0 ] );
channel.replace( QRegExp( ".*/" ), "" );
d->appName = channel;
channel = "QPE/Application/" + channel;
pidChannel = new QCopChannel( channel, this );
- connect( pidChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
- this, SLOT( pidMessage( const QCString &, const QByteArray & ) ) );
+ connect( pidChannel, SIGNAL( received(const QCString&,const QByteArray&) ),
+ this, SLOT( pidMessage(const QCString&,const QByteArray&) ) );
if ( f.isOpen() ) {
d->keep_running = FALSE;
QDataStream ds( &f );
QCString channel, message;
QByteArray data;
while ( !ds.atEnd() ) {
ds >> channel >> message >> data;
d->enqueueQCop( channel, message, data );
}
flock( f.handle(), LOCK_UN );
f.close();
f.remove();
}
for ( int a = 0; a < argc; a++ ) {
if ( qstrcmp( argv[ a ], "-preload" ) == 0 ) {
argv[ a ] = argv[ a + 1 ];
a++;
d->preloaded = TRUE;
argc -= 1;
}
else if ( qstrcmp( argv[ a ], "-preload-show" ) == 0 ) {
argv[ a ] = argv[ a + 1 ];
a++;
d->preloaded = TRUE;
d->forceshow = TRUE;
argc -= 1;
}
}
/* overide stored arguments */
setArgs( argc, argv );
#endif
#else
initApp( argc, argv );
#endif
// qwsSetDecoration( new QPEDecoration() );
#ifndef QT_NO_TRANSLATION
d->langs = Global::languageList();
for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it ) {
QString lang = *it;
installTranslation( lang + "/libopie.qm");
installTranslation( lang + "/libqpe.qm" );
installTranslation( lang + "/" + d->appName + ".qm" );
//###language/font hack; should look it up somewhere
#ifdef QWS
if ( lang == "ja" || lang == "zh_CN" || lang == "zh_TW" || lang == "ko" ) {
QFont fn = FontManager::unicodeFont( FontManager::Proportional );
setFont( fn );
}
#endif
}
#endif
applyStyle();
if ( type() == GuiServer ) {
setVolume();
}
installEventFilter( this );
QPEMenuToolFocusManager::initialize();
#ifdef QT_NO_QWS_CURSOR
// if we have no cursor, probably don't want tooltips
QToolTip::setEnabled( FALSE );
#endif
}
#ifdef QTOPIA_INTERNAL_INITAPP
void QPEApplication::initApp( int argc, char **argv )
{
delete pidChannel;
d->keep_running = TRUE;
d->preloaded = FALSE;
d->forceshow = FALSE;
QCString channel = QCString(argv[0]);
channel.replace(QRegExp(".*/"),"");
d->appName = channel;
#if QT_VERSION > 235
qt_fbdpy->setIdentity( channel ); // In Qt/E 2.3.6
#endif
channel = "QPE/Application/" + channel;
pidChannel = new QCopChannel( channel, this);
- connect( pidChannel, SIGNAL(received(const QCString &, const QByteArray &)),
- this, SLOT(pidMessage(const QCString &, const QByteArray &)));
+ connect( pidChannel, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(pidMessage(const QCString&,const QByteArray&)));
processQCopFile();
d->keep_running = d->qcopq.isEmpty();
for (int a=0; a<argc; a++) {
if ( qstrcmp(argv[a],"-preload")==0 ) {
argv[a] = argv[a+1];
a++;
d->preloaded = TRUE;
argc-=1;
} else if ( qstrcmp(argv[a],"-preload-show")==0 ) {
argv[a] = argv[a+1];
a++;
d->preloaded = TRUE;
d->forceshow = TRUE;
argc-=1;
}
}
/* overide stored arguments */
setArgs(argc, argv);
/* install translation here */
for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it )
installTranslation( (*it) + "/" + d->appName + ".qm" );
}
#endif
static QPtrDict<void>* inputMethodDict = 0;
static void createInputMethodDict()
{
if ( !inputMethodDict )
inputMethodDict = new QPtrDict<void>;
}
/*!
Returns the currently set hint to the system as to whether
widget \a w has any use for text input methods.
\sa setInputMethodHint() InputMethodHint
*/
QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget * w )
{
if ( inputMethodDict && w )
return ( InputMethodHint ) ( int ) inputMethodDict->find( w );
return Normal;
}
/*!
\enum QPEApplication::InputMethodHint
\value Normal the application sometimes needs text input (the default).
\value AlwaysOff the application never needs text input.
\value AlwaysOn the application always needs text input.
*/
/*!
Hints to the system that widget \a w has use for text input methods
as specified by \a mode.
\sa inputMethodHint() InputMethodHint
*/
void QPEApplication::setInputMethodHint( QWidget * w, InputMethodHint mode )
{
createInputMethodDict();
if ( mode == Normal ) {
inputMethodDict->remove
( w );
}
else {
inputMethodDict->insert( w, ( void* ) mode );
}
}
class HackDialog : public QDialog
{
public:
void acceptIt()
{
accept();
}
void rejectIt()
{
reject();
}
};
void QPEApplication::mapToDefaultAction( QWSKeyEvent * ke, int key )
{
// specialised actions for certain widgets. May want to
// add more stuff here.
if ( activePopupWidget() && activePopupWidget() ->inherits( "QListBox" )
&& activePopupWidget() ->parentWidget()
&& activePopupWidget() ->parentWidget() ->inherits( "QComboBox" ) )
key = Qt::Key_Return;
if ( activePopupWidget() && activePopupWidget() ->inherits( "QPopupMenu" ) )
key = Qt::Key_Return;
#ifdef QWS
ke->simpleData.keycode = key;
#endif
}
class HackWidget : public QWidget
{
public:
bool needsOk()
{
return ( getWState() & WState_Reserved1 );
}
};
/*!
\internal
*/
#ifdef QWS
bool QPEApplication::qwsEventFilter( QWSEvent * e )
{
if ( !d->notbusysent && e->type == QWSEvent::Focus ) {
if ( qApp->type() != QApplication::GuiServer ) {
QCopEnvelope e( "QPE/System", "notBusy(QString)" );
e << d->appName;
}
d->notbusysent = TRUE;
}
if ( type() == GuiServer ) {
switch ( e->type ) {
case QWSEvent::Mouse:
if ( e->asMouse() ->simpleData.state && !QWidget::find( e->window() ) )
emit clientMoused();
break;
default:
break;
}
}
if ( e->type == QWSEvent::Key ) {
QWSKeyEvent *ke = ( QWSKeyEvent * ) e;
if ( ke->simpleData.keycode == Qt::Key_F33 ) {
// Use special "OK" key to press "OK" on top level widgets
QWidget * active = activeWindow();
QWidget *popup = 0;
if ( active && active->isPopup() ) {
popup = active;
active = active->parentWidget();
}
if ( active && ( int ) active->winId() == ke->simpleData.window &&
!active->testWFlags( WStyle_Customize | WType_Popup | WType_Desktop ) ) {
if ( ke->simpleData.is_press ) {
if ( popup )
popup->close();
if ( active->inherits( "QDialog" ) ) {
HackDialog * d = ( HackDialog * ) active;
d->acceptIt();
return TRUE;
}
else if ( ( ( HackWidget * ) active ) ->needsOk() ) {
QSignal s;
s.connect( active, SLOT( accept() ) );
s.activate();
}
else {
// do the same as with the select key: Map to the default action of the widget:
mapToDefaultAction( ke, Qt::Key_Return );
}
}
}
}
else if ( ke->simpleData.keycode == Qt::Key_F30 ) {
// Use special "select" key to do whatever default action a widget has
mapToDefaultAction( ke, Qt::Key_Space );
}
else if ( ke->simpleData.keycode == Qt::Key_Escape &&
ke->simpleData.is_press ) {
// Escape key closes app if focus on toplevel
QWidget * active = activeWindow();
if ( active && active->testWFlags( WType_TopLevel ) &&
( int ) active->winId() == ke->simpleData.window &&
!active->testWFlags( WStyle_Dialog | WStyle_Customize | WType_Popup | WType_Desktop ) ) {
if ( active->inherits( "QDialog" ) ) {
HackDialog * d = ( HackDialog * ) active;
d->rejectIt();
return TRUE;
}
else if ( strcmp( argv() [ 0 ], "embeddedkonsole" ) != 0 ) {
active->close();
}
}
}
else if ( ke->simpleData.keycode >= Qt::Key_F1 && ke->simpleData.keycode <= Qt::Key_F29 ) {
// this should be if ( ODevice::inst ( )-> buttonForKeycode ( ... ))
// but we cannot access libopie function within libqpe :(
QWidget * active = activeWindow ( );
if ( active && ((int) active-> winId ( ) == ke-> simpleData.window )) {
if ( d-> kbgrabbed ) { // we grabbed the keyboard
QChar ch ( ke-> simpleData.unicode );
QKeyEvent qke ( ke-> simpleData. is_press ? QEvent::KeyPress : QEvent::KeyRelease,
ke-> simpleData.keycode,
ch. latin1 ( ),
ke-> simpleData.modifiers,
QString ( ch ),
ke-> simpleData.is_auto_repeat, 1 );
QObject *which = QWidget::keyboardGrabber ( );
if ( !which )
which = QApplication::focusWidget ( );
if ( !which )
which = QApplication::activeWindow ( );
if ( !which )
which = qApp;
QApplication::sendEvent ( which, &qke );
}
else { // we didn't grab the keyboard, so send the event to the launcher
QCopEnvelope e ( "QPE/Launcher", "deviceButton(int,int,int)" );
e << int( ke-> simpleData.keycode ) << int( ke-> simpleData. is_press ) << int( ke-> simpleData.is_auto_repeat );
}
}
return true;
}
}
if ( e->type == QWSEvent::Focus ) {
QWSFocusEvent * fe = ( QWSFocusEvent* ) e;
if ( !fe->simpleData.get_focus ) {
QWidget * active = activeWindow();
while ( active && active->isPopup() ) {
active->close();
active = activeWindow();
}
}
else {
// make sure our modal widget is ALWAYS on top
QWidget *topm = activeModalWidget();
if ( topm ) {
topm->raise();
}
}
if ( fe->simpleData.get_focus && inputMethodDict ) {
InputMethodHint m = inputMethodHint( QWidget::find( e->window() ) );
if ( m == AlwaysOff )
Global::hideInputMethod();
if ( m == AlwaysOn )
Global::showInputMethod();
}
}
return QApplication::qwsEventFilter( e );
}
#endif
/*!
Destroys the QPEApplication.
*/
QPEApplication::~QPEApplication()
{
ungrabKeyboard();
#if defined(Q_WS_QWS) && !defined(QT_NO_COP)
// Need to delete QCopChannels early, since the display will
// be gone by the time we get to ~QObject().
delete sysChannel;
delete pidChannel;
#endif
delete d;
}
/*!
Returns <tt>$OPIEDIR/</tt>.
*/
QString QPEApplication::qpeDir()
{
const char * base = getenv( "OPIEDIR" );
if ( base )
return QString( base ) + "/";
return QString( "../" );
}
/*!
Returns the user's current Document directory. There is a trailing "/".
.. well, it does now,, and there's no trailing '/'
*/
QString QPEApplication::documentDir()
{
const char* base = getenv( "HOME");
if ( base )
return QString( base ) + "/Documents";
return QString( "../Documents" );
}
static int deforient = -1;
/*!
\internal
*/
int QPEApplication::defaultRotation()
{
if ( deforient < 0 ) {
QString d = getenv( "QWS_DISPLAY" );
if ( d.contains( "Rot90" ) ) {
deforient = 90;
}
else if ( d.contains( "Rot180" ) ) {
deforient = 180;
}
else if ( d.contains( "Rot270" ) ) {
deforient = 270;
}
else {
deforient = 0;
}
}
return deforient;
}
/*!
\internal
*/
void QPEApplication::setDefaultRotation( int r )
{
if ( qApp->type() == GuiServer ) {
deforient = r;
setenv( "QWS_DISPLAY", QString( "Transformed:Rot%1:0" ).arg( r ).latin1(), 1 );
Config config("qpe");
config.setGroup( "Rotation" );
config.writeEntry( "Rot", r );
}
else {
#ifndef QT_NO_COP
{ QCopEnvelope e( "QPE/System", "setDefaultRotation(int)" );
e << r;
}
#endif
}
}
#include <qgfx_qws.h>
#include <qwindowsystem_qws.h>
extern void qws_clearLoadedFonts();
void QPEApplication::setCurrentMode( int x, int y, int depth )
{
// Reset the caches
qws_clearLoadedFonts();
QPixmapCache::clear();
// Change the screen mode
qt_screen->setMode(x, y, depth);
if ( qApp->type() == GuiServer ) {
// Reconfigure the GuiServer
qwsServer->beginDisplayReconfigure();
qwsServer->endDisplayReconfigure();
// Get all the running apps to reset
QCopEnvelope env( "QPE/System", "reset()" );
}
}
void QPEApplication::reset() {
// Reconnect to the screen
qt_screen->disconnect();
qt_screen->connect( QString::null );
// Redraw everything
applyStyle();
}
/*!
\internal
*/
void QPEApplication::applyStyle()
diff --git a/library/qpedialog.cpp b/library/qpedialog.cpp
index ac42972..da461b7 100644
--- a/library/qpedialog.cpp
+++ b/library/qpedialog.cpp
@@ -1,74 +1,74 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#define protected public
#include <qdialog.h>
#undef protected
#include "qpedialog.h"
#include <qpe/qpeapplication.h>
/**
* \brief This is the only c'tor.
*
* The parent of this Listener is the Dialog you pass. This means once
* the dialog is deleted this listener will be deleted too.
* This Listener listens on QPEApplication::appMessage signal and implements
* accept() and reject().
*
* \code
* QDialog *dialog = new YourDialog();
(void)new QPEDialogListener(dialog);
if( QPEApplication::execDialog(dialog) == QDialog::Accept ){
// do some stuff
}
delete dialog;
* \endcode
*
* @param di The dialog to handle
*/
QPEDialogListener::QPEDialogListener(QDialog *di ) : QObject(di)
{
dialog = di;
- connect(qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)),
- this, SLOT(appMessage(const QCString&, const QByteArray&)) );
+ connect(qApp, SIGNAL(appMessage(const QCString&,const QByteArray&)),
+ this, SLOT(appMessage(const QCString&,const QByteArray&)) );
}
/**
* d'tor
*/
QPEDialogListener::~QPEDialogListener() {}
/**
* \internal
*/
void QPEDialogListener::appMessage( const QCString &msg, const QByteArray & )
{
if (!dialog)
return;
if (msg == "accept()") {
dialog->accept();
} else if (msg == "reject()") {
dialog->reject();
}
}
diff --git a/library/storage.cpp b/library/storage.cpp
index 0ea465b..fcee689 100644
--- a/library/storage.cpp
+++ b/library/storage.cpp
@@ -1,401 +1,401 @@
/**********************************************************************
** Copyright (C) Holger 'zecke' Freyther <freyther@kde.org>
** Copyright (C) Lorn Potter <llornkcor@handhelds.org>
** Copyright (C) 2000 Trolltech AS. All rights reserved.
**
** This file is part of Opie Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include <qpe/storage.h>
#include <qcopchannel_qws.h>
#include <stdio.h>
#if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
#include <sys/vfs.h>
#include <mntent.h>
#endif
#ifdef Q_OS_MACX
# include <sys/param.h>
# include <sys/ucred.h>
# include <sys/mount.h>
# include <stdio.h> // For strerror()
# include <errno.h>
#endif /* Q_OS_MACX */
// Shouldn't be here ! (eilers)
// #include <sys/vfs.h>
// #include <mntent.h>
static bool isCF(const QString& m)
{
#ifndef Q_OS_MACX
FILE* f = fopen("/var/run/stab", "r");
if (!f) f = fopen("/var/state/pcmcia/stab", "r");
if (!f) f = fopen("/var/lib/pcmcia/stab", "r");
if ( f )
{
char line[1024];
char devtype[80];
char devname[80];
while ( fgets( line, 1024, f ) )
{
// 0 ide ide-cs 0 hda 3 0
if ( sscanf(line,"%*d %s %*s %*s %s", devtype, devname )==2 )
{
if ( QString(devtype) == "ide" && m.find(devname)>0 )
{
fclose(f);
return TRUE;
}
}
}
fclose(f);
}
#endif /* Q_OS_MACX */
return FALSE;
}
/*! \class StorageInfo storage.h
\brief The StorageInfo class describes the disks mounted on the file system.
This class provides access to the mount information for the Linux
filesystem. Each mount point is represented by the FileSystem class.
To ensure this class has the most up to date size information, call
the update() method. Note that this will automatically be signaled
by the operating system when a disk has been mounted or unmounted.
\ingroup qtopiaemb
*/
/*! Constructor that determines the current mount points of the filesystem.
The standard \a parent parameters is passed on to QObject.
*/
StorageInfo::StorageInfo( QObject *parent )
: QObject( parent )
{
mFileSystems.setAutoDelete( TRUE );
channel = new QCopChannel( "QPE/Card", this );
- connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
- this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
+ connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(cardMessage(const QCString&,const QByteArray&)) );
update();
}
/*! Returns the longest matching FileSystem that starts with the
same prefix as \a filename as its mount point.
*/
const FileSystem *StorageInfo::fileSystemOf( const QString &filename )
{
for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
{
if ( filename.startsWith( (*i)->path() ) )
return (*i);
}
return 0;
}
void StorageInfo::cardMessage( const QCString& msg, const QByteArray& )
{
if ( msg == "mtabChanged()" )
update();
}
/*! Updates the mount and free space available information for each mount
point. This method is automatically called when a disk is mounted or
unmounted.
*/
// cause of the lack of a d pointer we need
// to store informations in a config file :(
void StorageInfo::update()
{
//qDebug("StorageInfo::updating");
#if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
struct mntent *me;
FILE *mntfp = setmntent( "/etc/mtab", "r" );
QStringList curdisks;
QStringList curopts;
QStringList curfs;
bool rebuild = FALSE;
int n=0;
if ( mntfp )
{
while ( (me = getmntent( mntfp )) != 0 )
{
QString fs = me->mnt_fsname;
if ( fs.left(7)=="/dev/hd" || fs.left(7)=="/dev/sd"
|| fs.left(8)=="/dev/mtd" || fs.left(9) == "/dev/mmcd"
|| fs.left( 14 ) == "/dev/mmc/part1"
|| fs.left(5)=="tmpfs" || fs.left(9)=="/dev/root" )
{
n++;
curdisks.append(fs);
curopts.append( me->mnt_opts );
//qDebug("-->fs %s opts %s", fs.latin1(), me->mnt_opts );
curfs.append( me->mnt_dir );
bool found = FALSE;
for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
{
if ( (*i)->disk() == fs )
{
found = TRUE;
break;
}
}
if ( !found )
rebuild = TRUE;
}
}
endmntent( mntfp );
}
if ( rebuild || n != (int)mFileSystems.count() )
{
mFileSystems.clear();
QStringList::ConstIterator it=curdisks.begin();
QStringList::ConstIterator fsit=curfs.begin();
QStringList::ConstIterator optsIt=curopts.begin();
for (; it!=curdisks.end(); ++it, ++fsit, ++optsIt)
{
QString opts = *optsIt;
QString disk = *it;
QString humanname;
bool removable = FALSE;
if ( isCF(disk) )
{
humanname = tr("CF Card");
removable = TRUE;
}
else if ( disk == "/dev/hda1" )
{
humanname = tr("Hard Disk");
}
else if ( disk.left(9) == "/dev/mmcd" )
{
humanname = tr("SD Card");
removable = TRUE;
}
else if ( disk.left( 14 ) == "/dev/mmc/part1" )
{
humanname = tr("MMC Card");
removable = TRUE;
}
else if ( disk.left(7) == "/dev/hd" )
humanname = tr("Hard Disk") + " " + disk;
else if ( disk.left(7) == "/dev/sd" )
humanname = tr("SCSI Hard Disk") + " " + disk;
else if ( disk.left(14) == "/dev/mtdblock6" ) //openzaurus ramfs
humanname = tr("Internal Memory");
else if ( disk == "/dev/mtdblock1" || humanname == "/dev/mtdblock/1" )
humanname = tr("Internal Storage");
else if ( disk.left(14) == "/dev/mtdblock/" )
humanname = tr("Internal Storage") + " " + disk;
else if ( disk.left(13) == "/dev/mtdblock" )
humanname = tr("Internal Storage") + " " + disk;
else if ( disk.left(9) == "/dev/root" )
humanname = tr("Internal Storage") + " " + disk;
else if ( disk.left(5) == "tmpfs" ) //ipaqs /mnt/ramfs
humanname = tr("Internal Memory");
FileSystem *fs = new FileSystem( disk, *fsit, humanname, removable, opts );
mFileSystems.append( fs );
}
emit disksChanged();
}
else
{
// just update them
for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
i.current()->update();
}
#endif
}
bool deviceTab( const char *device)
{
QString name = device;
bool hasDevice=false;
#ifdef Q_OS_MACX
// Darwin (MacOS X)
struct statfs** mntbufp;
int count = 0;
if ( ( count = getmntinfo( mntbufp, MNT_WAIT ) ) == 0 )
{
qWarning("deviceTab: Error in getmntinfo(): %s",strerror( errno ) );
hasDevice = false;
}
for( int i = 0; i < count; i++ )
{
QString deviceName = mntbufp[i]->f_mntfromname;
qDebug(deviceName);
if( deviceName.left( name.length() ) == name )
hasDevice = true;
}
#else
// Linux
struct mntent *me;
FILE *mntfp = setmntent( "/etc/mtab", "r" );
if ( mntfp )
{
while ( (me = getmntent( mntfp )) != 0 )
{
QString deviceName = me->mnt_fsname;
// qDebug(deviceName);
if( deviceName.left(name.length()) == name)
{
hasDevice = true;
}
}
}
endmntent( mntfp );
#endif /* Q_OS_MACX */
return hasDevice;
}
/*!
* @fn static bool StorageInfo::hasCf()
* @brief returns whether device has Cf mounted
*
*/
bool StorageInfo::hasCf()
{
return deviceTab("/dev/hd");
}
/*!
* @fn static bool StorageInfo::hasSd()
* @brief returns whether device has SD mounted
*
*/
bool StorageInfo::hasSd()
{
return deviceTab("/dev/mmcd");
}
/*!
* @fn static bool StorageInfo::hasMmc()
* @brief returns whether device has mmc mounted
*
*/
bool StorageInfo::hasMmc()
{
bool hasMmc=false;
if( deviceTab("/dev/mmc/part"))
hasMmc=true;
if( deviceTab("/dev/mmcd"))
hasMmc=true;
return hasMmc;
}
/*! \fn const QList<FileSystem> &StorageInfo::fileSystems() const
Returns a list of all available mounted file systems.
\warning This may change in Qtopia 3.x to return only relevant Qtopia file systems (and ignore mount points such as /tmp)
*/
/*! \fn void StorageInfo::disksChanged()
Gets emitted when a disk has been mounted or unmounted, such as when
a CF c
*/
//---------------------------------------------------------------------------
FileSystem::FileSystem( const QString &disk, const QString &path, const QString &name, bool rem, const QString &o )
: fsdisk( disk ), fspath( path ), humanname( name ), blkSize(512), totalBlks(0), availBlks(0), removable( rem ), opts( o )
{
update();
}
void FileSystem::update()
{
#if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
struct statfs fs;
if ( !statfs( fspath.latin1(), &fs ) )
{
blkSize = fs.f_bsize;
totalBlks = fs.f_blocks;
availBlks = fs.f_bavail;
}
else
{
blkSize = 0;
totalBlks = 0;
availBlks = 0;
}
#endif
}
/*! \class FileSystem storage.h
\brief The FileSystem class describes a single mount point.
This class simply returns information about a mount point, including
file system name, mount point, human readable name, size information
and mount options information.
\ingroup qtopiaemb
\sa StorageInfo
*/
/*! \fn const QString &FileSystem::disk() const
Returns the file system name, such as /dev/hda3
*/
/*! \fn const QString &FileSystem::path() const
Returns the mount path, such as /home
*/
/*! \fn const QString &FileSystem::name() const
Returns the translated, human readable name for the mount directory.
*/
/*! \fn const QString &FileSystem::options() const
Returns the mount options
*/
/*! \fn long FileSystem::blockSize() const
Returns the size of each block on the file system.
*/
/*! \fn long FileSystem::totalBlocks() const
Returns the total number of blocks on the file system
*/
/*! \fn long FileSystem::availBlocks() const
Returns the number of available blocks on the file system
*/
/*! \fn bool FileSystem::isRemovable() const
Returns flag whether the file system can be removed, such as a CF card
would be removable, but the internal memory wouldn't
*/
/*! \fn bool FileSystem::isWritable() const
Returns flag whether the file system is mounted as writable or read-only.
Returns FALSE if read-only, TRUE if read and write.
*/
/*! \fn QStringList StorageInfo::fileSystemNames() const
Returns a list of filesystem names.
*/
diff --git a/library/timestring.cpp b/library/timestring.cpp
index 2fd0191..91c29ae 100644
--- a/library/timestring.cpp
+++ b/library/timestring.cpp
@@ -1,365 +1,365 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#include "timestring.h"
#include <qobject.h>
#include <qpe/qpeapplication.h> //for qApp
#include "config.h"
class TimeStringFormatKeeper : public QObject
{
Q_OBJECT
public:
static DateFormat currentFormat()
{
if ( !self )
self = new TimeStringFormatKeeper;
return self->format;
}
private slots:
void formatChanged( DateFormat f )
{
format = f;
}
private:
static TimeStringFormatKeeper *self;
DateFormat format;
TimeStringFormatKeeper()
: QObject( qApp )
{
Config config("qpe");
config.setGroup( "Date" );
format = DateFormat(QChar(config.readEntry("Separator", "/")[0]),
(DateFormat::Order)config .readNumEntry("ShortOrder", DateFormat::DayMonthYear),
(DateFormat::Order)config.readNumEntry("LongOrder", DateFormat::DayMonthYear));
connect( qApp, SIGNAL( dateFormatChanged(DateFormat) ),
- this, SLOT( formatChanged( DateFormat ) ) );
+ this, SLOT( formatChanged(DateFormat) ) );
}
};
TimeStringFormatKeeper *TimeStringFormatKeeper::self = 0;
QString DateFormat::toNumberString() const
{
QString buf = "";
// for each part of the order
for (int i = 0; i < 3; i++) {
// switch on the relavent 3 bits.
switch((_shortOrder >> (i * 3)) & 0x0007) {
case 0x0001:
buf += QObject::tr( "D" , "Shortcut for Day");
break;
case 0x0002:
buf += QObject::tr( "M", "Shortcur for Month" );
break;
case 0x0004:
buf += QObject::tr( "Y" );
break;
}
if (i < 2)
buf += _shortSeparator;
}
return buf;
}
QString DateFormat::toWordString() const
{
QString buf = "";
// for each part of the order
for (int i = 0; i < 3; i++) {
// switch on the relavent 3 bits.
switch((_longOrder >> (i * 3)) & 0x0007) {
case 0x0001:
buf += QObject::tr( "day" );
if (i < 2) {
if ((_shortOrder << ((i+1) * 3)) & 0x0007)
buf += ", ";
else
buf += " ";
}
break;
case 0x0002:
buf += QObject::tr( "month" );
if (i < 2)
buf += " ";
break;
case 0x0004:
buf += QObject::tr( "year" );
if (i < 2)
buf += ", ";
break;
}
}
return buf;
}
QString DateFormat::numberDate(const QDate &d, int v) const
{
QString buf = "";
int pad = 2;
// for each part of the order
for (int i = 0; i < 3; i++) {
// switch on the relavent 3 bits.
switch((_shortOrder >> (i * 3)) & 0x0007) {
case 0x0001:
if (pad==2) buf += QString().sprintf("%02d",d.day());
else buf += QString().sprintf("%d",d.day());
break;
case 0x0002:
if (i==0) { // no padding with only MM/DD/YY format
pad=0;
}
if (pad==2) buf += QString().sprintf("%02d",d.month());
else buf += QString().sprintf("%d",d.month());
break;
case 0x0004:
{
int year = d.year();
if (!(v & longNumber))
year = year % 100;
buf += QString().sprintf("%02d",year);
}
break;
}
if (i < 2)
buf += _shortSeparator;
}
return buf;
}
QString DateFormat::wordDate(const QDate &d, int v) const
{
QString buf = "";
// for each part of the order
if (v & showWeekDay) {
QString weekDay = d.dayName(d.dayOfWeek());
if (!(v & longWord)) {
weekDay = weekDay.left(3);
}
buf += weekDay;
if ((_longOrder & 0x0007) == 0x0002)
buf += ' ';
else
buf += ", ";
}
for (int i = 0; i < 3; i++) {
// switch on the relavent 3 bits.
switch((_longOrder >> (i * 3)) & 0x0007) {
case 0x0001:
if (i==1) {
buf += QString().sprintf("%02d, ",d.day());
} else {
buf += QString().sprintf("%2d",d.day());
if (separator()=='.') // 2002/1/11
buf += ". ";
else
buf += " ";
}
break;
case 0x0002:
{
QString monthName = d.monthName(d.month());
if (!(v & longWord)) {
monthName = monthName.left(3);
}
buf += monthName;
}
if (i < 2)
buf += " ";
break;
case 0x0004:
{
int year = d.year();
if (!(v & longNumber))
year = year % 100;
if (year < 10)
buf += "0";
buf += QString::number(year);
}
if (i < 2)
buf += ", ";
break;
}
}
return buf;
}
#ifndef QT_NO_DATASTREAM
void DateFormat::save(QDataStream &d) const
{
d << _shortSeparator.unicode();
uint v= _shortOrder;
d << v;
v = _longOrder;
d << v;
}
void DateFormat::load(QDataStream &d)
{
ushort value;
d >> value;
_shortSeparator = QChar(value);
uint v = 0;
d >> v;
_shortOrder = (Order)v;
v = 0;
d >> v;
_longOrder = (Order)v;
}
QDataStream &operator<<(QDataStream &s, const DateFormat&df)
{
df.save(s);
return s;
}
QDataStream &operator>>(QDataStream &s, DateFormat&df)
{
df.load(s);
return s;
}
#endif
QString TimeString::shortDate( const QDate &d, DateFormat dtf )
{
return dtf.wordDate(d);
}
QString TimeString::dateString( const QDate &d, DateFormat dtf )
{
return QObject::tr( dtf.wordDate(d, DateFormat::longNumber | DateFormat::longWord) );
}
QString TimeString::longDateString( const QDate &d, DateFormat dtf )
{
return QObject::tr( dtf.wordDate(d, DateFormat::showWeekDay | DateFormat::longNumber
| DateFormat::longWord) );
}
DateFormat TimeString::currentDateFormat()
{
return TimeStringFormatKeeper::currentFormat();
}
QString TimeString::dateString( const QDateTime &dt, bool ampm, bool seconds, DateFormat dtf )
{
const QDate& d = dt.date();
const QTime& t = dt.time();
// based on QDateTime::toString()
QString buf = timeString(t,ampm,seconds);
buf += " ";
buf += longDateString( d, dtf );
return buf;
}
QString TimeString::timeString( const QTime &t, bool ampm, bool seconds )
{
if ( !ampm ) {
if ( seconds )
return t.toString();
QString r = QString::number(t.hour());
if ( t.hour() < 10 ) r.prepend( "0" );
r.append( ":" );
if ( t.minute() < 10 ) r.append( "0" );
r.append(QString::number(t.minute()));
return r;
}
// ### else the hard case that should disappear in Qt 3.0
QString argString = seconds ? "%4:%5:%6 %7" : "%4:%5 %7";
int hour = t.hour();
QString strMin = QString::number( t.minute() );
QString strSec = QString::number( t.second() );
if ( hour > 12 )
argString = argString.arg( hour - 12, 2 );
else {
if ( hour == 0 )
argString = argString.arg( 12 );
else
argString = argString.arg( hour, 2 );
}
if ( t.minute() < 10 )
strMin.prepend( "0" );
if ( t.second() < 10 )
strSec.prepend( "0" );
argString = argString.arg( strMin );
if ( seconds )
argString = argString.arg( strSec );
if ( hour >= 12 )
argString = argString.arg( QObject::tr("PM") );
else
argString = argString.arg( QObject::tr("AM") );
return argString;
}
QString TimeString::shortTime( bool ampm, bool seconds )
{
static const char* const day[] = {
QT_TRANSLATE_NOOP( "QObject", "Mon" ),
QT_TRANSLATE_NOOP( "QObject", "Tue" ),
QT_TRANSLATE_NOOP( "QObject", "Wed" ),
QT_TRANSLATE_NOOP( "QObject", "Thu" ),
QT_TRANSLATE_NOOP( "QObject", "Fri" ),
QT_TRANSLATE_NOOP( "QObject", "Sat" ),
QT_TRANSLATE_NOOP( "QObject", "Sun" )
};
// just create a shorter time String
QDateTime dtTmp = QDateTime::currentDateTime();
QString strTime;
strTime = QObject::tr( day[dtTmp.date().dayOfWeek()-1] ) + " " +
timeString( dtTmp.time(), ampm, seconds );
return strTime;
}
QString TimeString::dateString( const QDateTime &t, bool ampm )
{
return dateString(t,ampm,FALSE);
}
QString TimeString::timeString( const QTime &t, bool ampm)
{
return timeString(t,ampm,FALSE);
}
QString TimeString::shortTime( bool ampm )
{
return shortTime(ampm,FALSE);
}
QString TimeString::numberDateString( const QDate &d, DateFormat dtf )
{
return dtf.numberDate(d);
}
QString TimeString::longNumberDateString( const QDate &d, DateFormat dtf )
{
return dtf.numberDate(d,DateFormat::longNumber);
}
#include "timestring.moc"
diff --git a/library/tzselect.cpp b/library/tzselect.cpp
index f28100b..848dfb7 100644
--- a/library/tzselect.cpp
+++ b/library/tzselect.cpp
@@ -1,302 +1,302 @@
/**********************************************************************
** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
**
** This file is part of the Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/
#define QTOPIA_INTERNAL_TZSELECT_INC_LOCAL
#include "tzselect.h"
#include "resource.h"
#include "config.h"
#include <qtoolbutton.h>
#include <qfile.h>
#include <stdlib.h>
#include <qcopchannel_qws.h>
#include <qpe/qpeapplication.h>
#include <qmessagebox.h>
/*!
\class TimeZoneSelector
\brief The TimeZoneSelector widget allows users to configure their time zone information.
\ingroup qtopiaemb
*/
class TimeZoneSelectorPrivate
{
public:
TimeZoneSelectorPrivate() : includeLocal(FALSE) {}
bool includeLocal;
};
TZCombo::TZCombo( QWidget *p, const char* n )
: QComboBox( p, n )
{
updateZones();
// check to see if TZ is set, if it is set the current item to that
QString tz = getenv("TZ");
if (parent()->inherits("TimeZoneSelector")) {
if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
// overide to the 'local' type.
tz = "None";
}
}
if ( !tz.isNull() ) {
int n = 0,
index = 0;
for ( QStringList::Iterator it=identifiers.begin();
it!=identifiers.end(); ++it) {
if ( *it == tz )
index = n;
n++;
}
setCurrentItem(index);
} else {
setCurrentItem(0);
}
// listen on QPE/System
#if !defined(QT_NO_COP)
QCopChannel *channel = new QCopChannel( "QPE/System", this );
- connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
- this, SLOT(handleSystemChannel(const QCString&, const QByteArray&)) );
+ connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+ this, SLOT(handleSystemChannel(const QCString&,const QByteArray&)) );
#endif
}
TZCombo::~TZCombo()
{
}
void TZCombo::updateZones()
{
QString cur = currentText();
clear();
identifiers.clear();
int curix=0;
QString tz = getenv("TZ");
bool tzFound = FALSE;
Config cfg("CityTime");
cfg.setGroup("TimeZones");
int listIndex = 0;
if (parent()->inherits("TimeZoneSelector")) {
if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
// overide to the 'local' type.
identifiers.append( "None" );
insertItem( tr("None") );
if ( cur == tr("None"))
curix = 0;
listIndex++;
}
}
int cfgIndex = 0;
while (1) {
QString zn = cfg.readEntry("Zone"+QString::number(cfgIndex), QString::null);
if ( zn.isNull() )
break;
if ( zn == tz )
tzFound = TRUE;
QString nm = cfg.readEntry("ZoneName"+QString::number(cfgIndex));
identifiers.append(zn);
insertItem(nm);
if ( nm == cur )
curix = listIndex;
++cfgIndex;
++listIndex;
}
if ( !listIndex ) {
QStringList list = timezoneDefaults();
for ( QStringList::Iterator it = list.begin(); it!=list.end(); ++it ) {
QString zn = *it;
QString nm = *++it;
if ( zn == tz )
tzFound = TRUE;
if ( nm == cur )
curix = listIndex;
identifiers.append(zn);
insertItem(nm);
++listIndex;
}
}
for (QStringList::Iterator it=extras.begin(); it!=extras.end(); ++it) {
insertItem(*it);
identifiers.append(*it);
if ( *it == cur )
curix = listIndex;
++listIndex;
}
if ( !tzFound && !tz.isEmpty()) {
int i = tz.find( '/' );
QString nm = tz.mid( i+1 ).replace(QRegExp("_"), " ");
identifiers.append(tz);
insertItem(nm);
if ( nm == cur )
curix = listIndex;
++listIndex;
}
setCurrentItem(curix);
}
void TZCombo::keyPressEvent( QKeyEvent *e )
{
// ### should popup() in Qt 3.0 (it's virtual there)
// updateZones();
QComboBox::keyPressEvent(e);
}
void TZCombo::mousePressEvent(QMouseEvent*e)
{
// ### should popup() in Qt 3.0 (it's virtual there)
// updateZones();
QComboBox::mousePressEvent(e);
}
QString TZCombo::currZone() const
{
return identifiers[currentItem()];
}
void TZCombo::setCurrZone( const QString& id )
{
for (int i=0; i< count(); i++) {
if ( identifiers[i] == id ) {
setCurrentItem(i);
return;
}
}
insertItem(id);
setCurrentItem( count() - 1);
identifiers.append(id);
extras.append(id);
}
void TZCombo::handleSystemChannel(const QCString&msg, const QByteArray&)
{
if ( msg == "timeZoneListChange()" ) {
updateZones();
}
}
/*!
Creates a new TimeZoneSelector with parent \a p and name \a n. The combobox will be
populated with the available timezones.
*/
TimeZoneSelector::TimeZoneSelector(QWidget* p, const char* n) :
QHBox(p,n)
{
d = new TimeZoneSelectorPrivate();
// build the combobox before we do any updates...
cmbTz = new TZCombo( this, "timezone combo" );
cmdTz = new QToolButton( this, "timezone button" );
cmdTz->setIconSet( Resource::loadIconSet( "citytime_icon" ) );
cmdTz->setMaximumSize( cmdTz->sizeHint() );
// set up a connection to catch a newly selected item and throw our
// signal
- QObject::connect( cmbTz, SIGNAL( activated( int ) ),
- this, SLOT( slotTzActive( int ) ) );
+ QObject::connect( cmbTz, SIGNAL( activated(int) ),
+ this, SLOT( slotTzActive(int) ) );
QObject::connect( cmdTz, SIGNAL( clicked() ),
this, SLOT( slotExecute() ) );
}
/*!
Destroys a TimeZoneSelector.
*/
TimeZoneSelector::~TimeZoneSelector()
{
}
void TimeZoneSelector::setLocalIncluded(bool b)
{
d->includeLocal = b;
cmbTz->updateZones();
}
bool TimeZoneSelector::localIncluded() const
{
return d->includeLocal;
}
/*!
Returns the currently selected timezone as a string in location format, e.g.
\code Australia/Brisbane \endcode
*/
QString TimeZoneSelector::currentZone() const
{
return cmbTz->currZone();
}
/*!
Sets the current timezone to \a id.
*/
void TimeZoneSelector::setCurrentZone( const QString& id )
{
cmbTz->setCurrZone( id );
}
/*! \fn void TimeZoneSelector::signalNewTz( const QString& id )
This signal is emitted when a timezone has been selected by the user. The id
is a \l QString in location format, eg \code Australia/Brisbane \endcode
*/
void TimeZoneSelector::slotTzActive( int )
{
emit signalNewTz( cmbTz->currZone() );
}
void TimeZoneSelector::slotExecute( void )
{
// execute the world time application...
if (QFile::exists(QPEApplication::qpeDir()+"bin/citytime"))
Global::execute( "citytime" );
else
QMessageBox::warning(this,tr("citytime executable not found"),
tr("In order to choose the time zones,\nplease install citytime."));
}
QStringList timezoneDefaults( void )
{
QStringList tzs;
// load up the list just like the file format (citytime.cpp)
tzs.append( "America/New_York" );
tzs.append( "New York" );
tzs.append( "America/Los_Angeles" );
tzs.append( "Los Angeles" );
tzs.append( "Australia/Brisbane" );
tzs.append( "Brisbane" );
tzs.append( "Europe/Berlin" );
tzs.append( "Berlin" );
tzs.append( "Asia/Tokyo" );
tzs.append( "Tokyo" );
tzs.append( "America/Denver" );
tzs.append( "Denver" );
return tzs;
}