abeditor.cpp

来自「Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3」· C++ 代码 · 共 2,205 行 · 第 1/5 页

    Q_UNUSED( le ); 
    sm.setItalic( TRUE );
#endif
    label->setFont(sm);
}

void AbDetailEditor::setFields( const QMap<PimContact::ContactFields, QString> &f )
{
    //FIXME : This loop is pointless - make AbDetailEditor an adt and derive address and name editors from that
    myFields = f;
    QWidget *container = mView->widget();

    bool haveFileAs = FALSE;
    if ( ! fileAsCombo )
	fileAsCombo = new FileAsCombo( container );

    const QMap<PimContact::ContactFields, QString> dn = displayNames();
    QGridLayout *gl = new QGridLayout( container, myFields.count()+1, 3, 3, 0 );
#ifdef QTOPIA_DESKTOP
    gl->setResizeMode( QLayout::FreeResize );
#endif
#ifdef QTOPIA_DESKTOP
    gl->setSpacing( 4 );
#else
    gl->addColSpacing(1,4);
#endif

    QWidget *lastEditor = 0, *editor;
    int fieldInTabNum=0;

    //Map may differ in ordering to what we want ; get a value list for the fields we're editing
    QValueList<PimContact::ContactFields> guiList = guiValueList( f );

    for ( QValueList<PimContact::ContactFields>::ConstIterator fieldKey = guiList.begin() ;
          fieldKey != guiList.end() ; ++fieldKey ) {

	QLabel *label = new QLabel( dn[ *fieldKey ], container );
	label->setAlignment(AlignRight|AlignVCenter);

	// do a switch on the field type; most are line edits, the exceptions get a case, the default
	// is a linedit
	editor = 0;
	int cLen = 0;
	int i;
	switch ( *fieldKey ) {
	case PimContact::Suffix:
	    suffixCombo = new QComboBox( FALSE, container );
	    suffixCombo->setEditable( FALSE );
	    suffixCombo->setDuplicatesEnabled( FALSE );
	    suffixCombo->setAutoCompletion( TRUE );

	    connect(suffixCombo, SIGNAL(textChanged(const QString&)),
		    fileAsCombo, SLOT(setSuffix(const QString&)));

	    suffixCombo->insertItem( "", 0 );
	    suffixCombo->insertStringList( QStringList::split( ';', gNameSuffixStr ) );

	    cLen = suffixCombo->count();
	    for( i = 0; i < cLen ; ++i )
	    {
		if( myFields[ *fieldKey ]  == suffixCombo->text( i ) )
		{
		    suffixCombo->setCurrentItem( i );
		    break;
		}
	    }

	    editor = suffixCombo;
	    break;

	case PimContact::NameTitle:
	    titleCombo = new QComboBox( FALSE, container );
	    titleCombo->setEditable( FALSE );
	    titleCombo->setDuplicatesEnabled( FALSE );
	    titleCombo->setAutoCompletion( TRUE );

	    connect(titleCombo, SIGNAL(textChanged(const QString&)),
		    fileAsCombo, SLOT(setPrefix(const QString&)));

	    titleCombo->insertItem( "", 0 );
	    titleCombo->insertStringList( QStringList::split( ';', gNamePrefixStr ) );

	    cLen = titleCombo->count();
	    for( i = 0; i < cLen ; ++i )
	    {
		if( myFields[ *fieldKey ] == titleCombo->text( i ) )
		{
		    titleCombo->setCurrentItem( i );
		    break;
		}
	    }

	    editor = titleCombo;
	    break;
	case PimContact::FileAs:
	    haveFileAs = TRUE;
	    editor = fileAsCombo;
	    fileAsCombo->setSelected( myFields[ *fieldKey ] );
	    break;
	default:
	    {
		//FIXME : ugly temporary solution
		QLineEdit *lineedit = new QLineEdit( container );
		switch( *fieldKey )
		{
		    case PimContact::FirstNamePronunciation:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setFirstNamePro(const QString&)) );
			break;
		    case PimContact::LastNamePronunciation:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setLastNamePro(const QString&)) );
			break;
		    case PimContact::FirstName:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setFirstName(const QString&)) );
			break;
		    case PimContact::MiddleName:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setMiddleName(const QString&)) );
			break;
		    case PimContact::LastName:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setLastName(const QString&)) );
			break;
		    case PimContact::Nickname:
			connect( lineedit, SIGNAL(textChanged(const QString&)),
				fileAsCombo, SLOT(setNickName(const QString&)) );
			break;
                    default:
                        break;
		}

		if ( *fieldKey == PimContact::FirstNamePronunciation
		  || *fieldKey == PimContact::LastNamePronunciation )
		    adjustPronWidgets(label,lineedit);
		else if( *fieldKey == PimContact::BusinessZip ||
			 *fieldKey == PimContact::HomeZip )
		    QPEApplication::setInputMethodHint( lineedit, QPEApplication::Number );
		lineedit->setText( myFields[ *fieldKey ] );
		lineEdits.insert( *fieldKey, lineedit );
		editor = lineedit;
	    }
	    break;
	};

	if ( editor ) 
	{
	    // add the editor to the layout
	    gl->addWidget( label, fieldInTabNum, 0 );
	    gl->addWidget( editor, fieldInTabNum, 2 );
	    if ( lastEditor ) {
		setTabOrder( lastEditor, editor );
	    }
	    lastEditor = editor;

	    // increment the field number for this tab
	    fieldInTabNum++;
	} else {
	    delete label;
	    label = 0;
	}
    }
    QSpacerItem *verticleSpacer = new QSpacerItem( 1, 1, QSizePolicy::Minimum,
						   QSizePolicy::Expanding );
    gl->addItem( verticleSpacer, fieldInTabNum, 2 );

    if( !haveFileAs ) // not editing name, don't need file as combo
    {
	delete fileAsCombo;
	fileAsCombo = 0;
    }
}

const QMap<PimContact::ContactFields, QString> AbDetailEditor::displayNames() const
{
    QMap<PimContact::ContactFields, QString> shortNames;
    const QMap<int, QString> &longNames= PimContact::trFieldsMap(); // use field names from PimContact

    //names for name fields
    shortNames[PimContact::NameTitle] = longNames[PimContact::NameTitle];
    shortNames[PimContact::FirstName] = longNames[PimContact::FirstName];
    shortNames[PimContact::FirstNamePronunciation] = longNames[PimContact::FirstNamePronunciation];
    shortNames[PimContact::MiddleName] = longNames[PimContact::MiddleName];
    shortNames[PimContact::LastName] = longNames[PimContact::LastName];
    shortNames[PimContact::LastNamePronunciation] = longNames[PimContact::LastNamePronunciation];
    shortNames[PimContact::Suffix] = longNames[PimContact::Suffix];
    shortNames[PimContact::Nickname] = longNames[PimContact::Nickname];
    shortNames[PimContact::FileAs] = longNames[PimContact::FileAs];

    QString street = tr("Street"),
	    city = tr("City"),
	    state = tr("State"),
	    zip = tr("Zip"),
	    country = tr("Country")
	    ;

    shortNames[PimContact::BusinessStreet] = street;
    shortNames[PimContact::BusinessCity] = city;
    shortNames[PimContact::BusinessState] = state;
    shortNames[PimContact::BusinessZip] = zip;
    shortNames[PimContact::BusinessCountry] = country;

    shortNames[PimContact::HomeStreet] = street;
    shortNames[PimContact::HomeCity] = city;
    shortNames[PimContact::HomeState] = state;
    shortNames[PimContact::HomeZip] = zip;
    shortNames[PimContact::HomeCountry] = country;

    return shortNames;
}

QMap<PimContact::ContactFields, QString> AbDetailEditor::fields() const
{
    return myFields;
}
    
//------------------------------------------------------------------------

AbstractField::AbstractField( QWidget *parent , const char *name )
    : QWidget( parent, name ), mModified( FALSE ), mHaveFieldsPrevChanged( FALSE ), detailEditor(0)
{
}

AbstractField::~AbstractField()
{
}

bool AbstractField::modified() const
{
    return mModified;
}

void AbstractField::setModified( bool b )
{
    mModified = mHaveFieldsPrevChanged = b;
}

void AbstractField::setFields( const QMap<PimContact::ContactFields, QString> &f )
{
    myFields = f;

    fieldsChanged();
}

QMap<PimContact::ContactFields, QString> AbstractField::fields() const
{
    return myFields;
}

bool AbstractField::isEmpty() const
{
    for( QMap<PimContact::ContactFields, QString>::ConstIterator it = myFields.begin() ; it != myFields.end() ; ++it )
    {
	QString str = it.data().stripWhiteSpace();
	if( !str.isEmpty() )
	    return FALSE;
    }
    return TRUE;
}

void AbstractField::details()
{
    parse();

    detailEditor = new AbDetailEditor( (QWidget *)parent(), "detailEditor" );
    detailEditor->setCaption( tr("Edit %1").arg( fieldName() ) );

    detailEditor->setFields( fields() );

#ifdef QTOPIA_DESKTOP
    if( detailEditor->exec() )
#else
    if( QPEApplication::execDialog( detailEditor ) )
#endif
    {
	setFields( detailEditor->fields() );
	fieldsChanged();
    }

    delete detailEditor;
    detailEditor = 0;
}

QStringList AbstractField::tokenize( const QString &input ) const
{
    QStringList tokens;
    const QString &in = input;
    int len = input.length();

    int i = 0;
    while( i < len )
    {
	if( in[i] == '\n' ) // new line is a valid token
	{
	    tokens += QString( QChar('\n') );
	    ++i;
	    //skip any following newlines
	    //while( i < len && in[i] == '\n' ) ++i;
	    //make newlines count for address field

	}
	else if( in[i].isSpace() ) // skip whitespace
	{
	    while( i < len && in[i].isSpace() ) ++i;
	}
	else if( in[i] == ',' ) // other meaningful tokens
	{
	    tokens += QString( QChar(in[i]) );
	    ++i;
	}
	else if( in[i] == '('  ) // nickname
	{
	    tokens += "(";
	    QString nick;
	    ++i;
	    while( i < len && in[i] != ')' ) nick += in[i++];
	    tokens += nick;
	    tokens += ")";
	    ++i;
	}
	else if( in[i] == '\"' || in[i] == '\'' ) //string literal
	{
	    //include quotes in the token so we know it's a string literal
	    char quote = in[i];
	    QString literal;
	    literal += quote;
	    ++i;
	    while( i < len && in[i] != quote ) literal += in[i++];
	    literal += quote;
	    ++i;
	    tokens += literal;
	}
	else // identifier
	{
	    QString identifier;
	    while( i < len && !in[i].isSpace() && in[i] != ','  ) identifier += in[i++];
	    tokens += identifier;
	}
	
    }
    /*
    qDebug("Printing tokens.\n");
    QStringList::Iterator it;
    for( it = tokens.begin() ; it != tokens.end() ; ++it )
	qDebug("%s\n", (*it).latin1());
	*/
    return tokens;
}

//------------------------------------------------------------------------

AbstractName::AbstractName( QWidget *parent , const char *name )
    : AbstractField( parent, name ), mainWidget(0)
{
    QHBoxLayout *layout = new QHBoxLayout( this );
    mainWidget = new QLineEdit( this, name );
    setFocusProxy(mainWidget);

#ifdef QTOPIA_PHONE
    ContextMenu *contextMenu = ContextMenu::menuFor(mainWidget);

    QAction *actionDetails = new QAction( tr( "Details" ), Resource::loadIconSet( "field-details" ), QString::null,
			      0, this, 0 );
    connect( actionDetails, SIGNAL(activated()), this, SLOT(details()) );
    contextMenu->insertSeparator(0);
    contextMenu->insertAction(actionDetails, 0);
#endif

//    setSizePolicy( mainWidget->sizePolicy() );
//   mainWidget->setSizePolicy( QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding) );

    layout->addWidget( mainWidget );

    prefixes = QStringList::split( ';', gNamePrefixStr );
    suffixes = QStringList::split( ';', gNameSuffixStr );

    connect( mainWidget, SIGNAL(textChanged(const QString&)), this, SLOT(textChanged()) );
}

AbstractName::~AbstractName()
{
}

bool AbstractName::isEmpty() const
{
    return mainWidget->text().isEmpty();
}

QString AbstractName::fieldName() const
{
    return tr("Name");
}

void AbstractName::parse()
{
/*
1: name = [known-prefix] given-name [nick] {middle-name} family-name [known-suffix] [pron] 
2: name = known-prefix family-name [known-suffix] [pron] 
3: name = given-name [known-suffix] [pron] 
4: name = family-name ',' [known-prefix] given-name [nick] {middle-name} [known-suffix] [pron]
*/
    QString prefix, suffix, firstName, nickName, middleName, lastName, firstNamePro, lastNamePro;
    QString newText = mainWidget->text();
    if( newText.isEmpty() )
    {
	myFields[PimContact::NameTitle] = 
	myFields[PimContact::FirstName] = 
	myFields[PimContact::FirstNamePronunciation] =
	myFields[PimContact::MiddleName] = 
	myFields[PimContact::LastName] = 
	myFields[PimContact::LastNamePronunciation] = 
	myFields[PimContact::Suffix] =
	myFields[PimContact::Nickname] = QString("");
	return;
    }

    QStringList tokens = tokenize( newText );
    int tokCount = tokens.count();
    int i = 0;
    //eliminate different possibilities based on the tokens
    if( tokens[1] == "," )
    {
	// rule 4
	lastName = tokens[i++];
	++i;
	QString fAffix = formattedAffix( tokens[i], prefixes );
	if( fAffix.length() )
	{
	    prefix = fAffix;
	    ++i;
	}
	firstName = tokens[i++];
	if( i < tokCount && tokens[i] == "(" )
	{
	    ++i;
	    nickName = tokens[i++];
	    ++i; // skip closing )
	}
	if( i < tokCount && !isQuote( tokens[i][0] ) )
	    middleName = tokens[i++];