kexiformscrollview.cpp

/* This file is part of the KDE project
   Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
   Copyright (C) 2004-2006 Jaroslaw Staniek <js@iidea.pl>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include "kexiformscrollview.h"
//#include "kexiformview.h"
 
#include <formeditor/form.h>
#include <formeditor/formmanager.h>
#include <formeditor/objecttree.h>
#include <formeditor/commands.h>
#include <widget/utils/kexirecordmarker.h>
 
#include <tdepopupmenu.h>
#include <kdebug.h>
 
KexiFormScrollView::KexiFormScrollView(TQWidget *parent, bool preview)
 : KexiScrollView(parent, preview)
 , KexiRecordNavigatorHandler()
 , KexiSharedActionClient()
 , KexiDataAwareObjectInterface()
 , KexiFormDataProvider()
 , KexiFormEventHandler()
{
    m_currentLocalSortColumn = -1; /* no column */
    m_localSortingOrder = -1; /* no sorting */
    m_previousItem = 0;
    m_navPanel = m_scrollViewNavPanel; //copy this pointer from KexiScrollView
    if (preview) {
        setRecordNavigatorVisible(true);
//tmp
//      recordNavigator()->setEditingIndicatorEnabled(true);
//      recordNavigator()->showEditingIndicator(true);
    }
 
    connect(this, TQ_SIGNAL(resizingStarted()), this, TQ_SLOT(slotResizingStarted()));
 
    m_popupMenu = new TDEPopupMenu(this, "contextMenu");
 
//  setFocusPolicy(NoFocus);
}
 
KexiFormScrollView::~KexiFormScrollView()
{
    if (m_owner)
        delete m_data;
    m_data = 0;
}
 
void
KexiFormScrollView::show()
{
    KexiScrollView::show();
 
#if 0 //moved to KexiFormView, OK?
    //now get resize mode settings for entire form
    if (m_preview) {
        KexiFormView* fv = dynamic_cast<KexiFormView*>(parent());
        int resizeMode = fv ? fv->resizeMode() : KexiFormView::ResizeAuto;
        if (resizeMode == KexiFormView::ResizeAuto)
            setResizePolicy(AutoOneFit);
    }
#endif
}
 
void
KexiFormScrollView::slotResizingStarted()
{
    if(m_form && KFormDesigner::FormManager::self())
        setSnapToGrid(KFormDesigner::FormManager::self()->snapWidgetsToGrid(), m_form->gridSize());
    else
        setSnapToGrid(false);
}
 
int KexiFormScrollView::rowsPerPage() const
{
    return 10;
}
 
void KexiFormScrollView::selectCellInternal()
{
    //m_currentItem is already set by KexiDataAwareObjectInterface::setCursorPosition()
    if (m_currentItem) {
        if (m_currentItem!=m_previousItem) {
            fillDataItems(*m_currentItem, cursorAtNewRow());
            m_previousItem = m_currentItem;
        }
    }
    else {
        m_previousItem = 0;
    }
}
 
void KexiFormScrollView::ensureCellVisible(int row, int col/*=-1*/)
{
    Q_UNUSED( row );
    Q_UNUSED( col );
//  if (m_currentItem)
        //fillDataItems(*m_currentItem);
 
//  if (m_form->tabStops()->first() && m_form->tabStops()->first()->widget())
//      m_form->tabStops()->first()->widget()->setFocus();
}
 
void KexiFormScrollView::moveToRecordRequested(uint r)
{
    selectRow(r);
}
 
void KexiFormScrollView::moveToLastRecordRequested()
{
    selectLastRow();
}
 
void KexiFormScrollView::moveToPreviousRecordRequested()
{
    selectPrevRow();
}
 
void KexiFormScrollView::moveToNextRecordRequested()
{
    selectNextRow();
}
 
void KexiFormScrollView::moveToFirstRecordRequested()
{
    selectFirstRow();
}
 
void KexiFormScrollView::clearColumnsInternal(bool repaint)
{
    Q_UNUSED( repaint );
}
 
void KexiFormScrollView::addHeaderColumn(const TQString& caption, const TQString& description, 
    const TQIconSet& icon, int width)
{
    Q_UNUSED( caption );
    Q_UNUSED( description );
    Q_UNUSED( icon );
    Q_UNUSED( width );
 
}
 
int KexiFormScrollView::currentLocalSortingOrder() const
{
    return m_localSortingOrder;
}
 
int KexiFormScrollView::currentLocalSortColumn() const
{
    return m_currentLocalSortColumn;
}
 
void KexiFormScrollView::setLocalSortingOrder(int col, int order)
{
    m_currentLocalSortColumn = col;
    m_localSortingOrder = order;
}
 
void KexiFormScrollView::sortColumnInternal(int col, int order)
{
    Q_UNUSED( col );
    Q_UNUSED( order );
}
 
void KexiFormScrollView::updateGUIAfterSorting()
{
}
 
void KexiFormScrollView::createEditor(int row, int col, const TQString& addText, 
    bool removeOld)
{
    Q_UNUSED( row );
    Q_UNUSED( addText );
    Q_UNUSED( removeOld );
 
    if (isReadOnly()) {
        kexipluginsdbg << "KexiFormScrollView::createEditor(): DATA IS READ ONLY!"<<endl;
        return;
    }
    if (column( col )->isReadOnly()) {
        kexipluginsdbg << "KexiFormScrollView::createEditor(): COL IS READ ONLY!"<<endl;
        return;
    }
 
    const bool startRowEdit = !m_rowEditing; //remember if we're starting row edit
 
    if (!m_rowEditing) {
        //we're starting row editing session
        m_data->clearRowEditBuffer();
        
        m_rowEditing = true;
        //indicate on the vheader that we are editing:
        if (m_verticalHeader)
            m_verticalHeader->setEditRow(m_curRow);
        if (isInsertingEnabled() && m_currentItem==m_insertItem) {
            //we should know that we are in state "new row editing"
            m_newRowEditing = true;
            //'insert' row editing: show another row after that:
            m_data->append( m_insertItem );
            //new empty insert item
            m_insertItem = m_data->createItem(); //new KexiTableItem(dataColumns());
//          updateContents();
            if (m_verticalHeader)
                m_verticalHeader->addLabel();
//          m_verticalHeaderAlreadyAdded = true;
            updateWidgetContentsSize();
            //refr. current and next row
//          updateContents(columnPos(0), rowPos(row), viewport()->width(), d->rowHeight*2);
//js: warning this breaks behaviour (cursor is skipping, etc.): tqApp->processEvents(500);
//          ensureVisible(columnPos(m_curCol), rowPos(row+1)+d->rowHeight-1, columnWidth(m_curCol), d->rowHeight);
 
//          m_verticalHeader->setOffset(contentsY());
        }
    }   
 
    m_editor = editor(col); //m_dataItems.at(col);
    if (!m_editor)
        return;
 
    if (startRowEdit) {
        recordNavigator()->showEditingIndicator(true);
//      recordNavigator()->updateButtons(); //refresh 'next btn'
 
        emit rowEditStarted(m_curRow);
    }
}
 
KexiDataItemInterface *KexiFormScrollView::editor( int col, bool ignoreMissingEditor )
{
    Q_UNUSED( ignoreMissingEditor );
 
    if (!m_data || col<0 || col>=columns())
        return 0;
 
    return dynamic_cast<KexiFormDataItemInterface*>(dbFormWidget()->orderedDataAwareWidgets()->at( col ));
//  KexiFormDataItemInterface *item = m_dataItems.at(col);
    //return item;
 
/*
    KexiTableViewColumn *tvcol = m_data->column(col);
//  int t = tvcol->field->type();
 
    //find the editor for this column
    KexiDataItemInterface *editor = d->editors[ tvcol ];
    if (editor)
        return editor;
 
    //not found: create
//  editor = KexiCellEditorFactory::createEditor(*m_data->column(col)->field, this);
    editor = KexiCellEditorFactory::createEditor(*m_data->column(col), this);
    if (!editor) {//create error!
        if (!ignoreMissingEditor) {
            //js TODO: show error???
            cancelRowEdit();
        }
        return 0;
    }
    editor->hide();
    connect(editor,TQ_SIGNAL(editRequested()),this,TQ_SLOT(slotEditRequested()));
    connect(editor,TQ_SIGNAL(cancelRequested()),this,TQ_SLOT(cancelEditor()));
    connect(editor,TQ_SIGNAL(acceptRequested()),this,TQ_SLOT(acceptEditor()));
 
    editor->resize(columnWidth(col)-1, rowHeight()-1);
    editor->installEventFilter(this);
    if (editor->widget())
        editor->widget()->installEventFilter(this);
    //store
    d->editors.insert( tvcol, editor );
    return editor;*/
}
 
void KexiFormScrollView::editorShowFocus( int row, int col )
{
    Q_UNUSED( row );
    Q_UNUSED( col );
//  if (m_currentItem)
//      m_provider->fillDataItems(*m_currentItem);
}
 
void KexiFormScrollView::updateCell(int row, int col)
{
    Q_UNUSED( row );
    Q_UNUSED( col );
}
 
void KexiFormScrollView::updateCurrentCell()
{
}
 
void KexiFormScrollView::updateRow(int row)
{
    Q_UNUSED(row)
}
 
void KexiFormScrollView::updateWidgetContents()
{
}
 
void KexiFormScrollView::updateWidgetContentsSize()
{
}
 
void KexiFormScrollView::updateWidgetScrollBars()
{
}
 
void KexiFormScrollView::slotRowRepaintRequested(KexiTableItem& item)
{
    Q_UNUSED( item );
}
 
/*void KexiFormScrollView::slotAboutToDeleteRow(KexiTableItem& item, 
    KexiDB::ResultInfo* result, bool repaint)
{
}*/
 
/*void KexiFormScrollView::slotRowDeleted()
{
}*/
 
void KexiFormScrollView::slotRowInserted(KexiTableItem *item, bool repaint)
{
    Q_UNUSED( item );
    Q_UNUSED( repaint );
}
 
void KexiFormScrollView::slotRowInserted(KexiTableItem *item, uint row, bool repaint)
{
    Q_UNUSED( item );
    Q_UNUSED( row );
    Q_UNUSED( repaint );
}
 
void KexiFormScrollView::slotRowsDeleted( const TQValueList<int> & )
{
}
 
KexiDBForm* KexiFormScrollView::dbFormWidget() const
{
    return dynamic_cast<KexiDBForm*>(m_widget);
}
 
int KexiFormScrollView::columns() const
{
    return dbFormWidget()->orderedDataAwareWidgets()->count(); //m_dataItems.count();
}
 
/*uint KexiFormScrollView::fieldNumberForColumn(int col)
{
    KexiFormDataItemInterface *item = dynamic_cast<KexiFormDataItemInterface*>(dbFormWidget()->orderedDataAwareWidgets()->at( col ));
    if (!item)
        return -1;
    KexiFormDataItemInterfaceToIntMap::ConstIterator it(m_fieldNumbersForDataItems.find( item ));
    return it!=m_fieldNumbersForDataItems.constEnd() ? it.data() : -1;
}*/
 
bool KexiFormScrollView::columnEditable(int col)
{
    kexipluginsdbg << "KexiFormScrollView::columnEditable(" << col << ")" << endl;
    foreach_list (TQPtrListIterator<KexiFormDataItemInterface>, it, m_dataItems) {
        kexipluginsdbg << (dynamic_cast<TQWidget*>(it.current()) ? dynamic_cast<TQWidget*>(it.current())->name() : "" ) 
            << " " << it.current()->dataSource() << endl;
    }
    kexipluginsdbg << "-- focus widgets --" << endl;
    foreach_list (TQPtrListIterator<TQWidget>, it, *dbFormWidget()->orderedFocusWidgets()) {
        kexipluginsdbg << it.current()->name() << endl;
    }
    kexipluginsdbg << "-- data-aware widgets --" << endl;
    foreach_list (TQPtrListIterator<TQWidget>, it, *dbFormWidget()->orderedDataAwareWidgets()) {
        kexipluginsdbg << it.current()->name() << endl;
    }
 
    //int index = dbFormWidget()->indexForDataItem( item );
//  KexiFormDataItemInterface *item1 = dynamic_cast<KexiFormDataItemInterface*>(dbFormWidget()->orderedFocusWidgets()->at( col ));
    KexiFormDataItemInterface *item = dynamic_cast<KexiFormDataItemInterface*>(dbFormWidget()->orderedDataAwareWidgets()->at( col ));
 
    if (!item || item->isReadOnly())
        return false;
 
//  KexiFormDataItemInterfaceToIntMap::ConstIterator it(m_fieldNumbersForDataItems.find( item ));
//  return KexiDataAwareObjectInterface::columnEditable( it!=m_fieldNumbersForDataItems.constEnd() ? it.data() : -1 );
    return KexiDataAwareObjectInterface::columnEditable( col );
}
 
void KexiFormScrollView::valueChanged(KexiDataItemInterface* item)
{
    if (!item)
        return;
    //only signal start editing when no row editing was started already
    kexipluginsdbg << "** KexiFormScrollView::valueChanged(): editedItem=" 
        << (dbFormWidget()->editedItem ? dbFormWidget()->editedItem->value().toString() : TQString())
        << ", "
        << (item ? item->value().toString() : TQString())
        << endl;
    if (dbFormWidget()->editedItem!=item) {
        kexipluginsdbg << "**>>>    dbFormWidget()->editedItem = dynamic_cast<KexiFormDataItemInterface*>(item)" << endl;
        dbFormWidget()->editedItem = dynamic_cast<KexiFormDataItemInterface*>(item);
        startEditCurrentCell();
    }
    fillDuplicatedDataItems(dynamic_cast<KexiFormDataItemInterface*>(item), item->value());
    
    //value changed: clear 'default value' mode (e.g. a blue italic text)
    dynamic_cast<KexiFormDataItemInterface*>(item)->setDisplayDefaultValue(dynamic_cast<TQWidget*>(item), false);
}
 
bool KexiFormScrollView::cursorAtNewRow() const
{
    return isInsertingEnabled() && ( m_currentItem==m_insertItem || m_newRowEditing );
}
 
void KexiFormScrollView::initDataContents()
{
    KexiDataAwareObjectInterface::initDataContents();
 
    if (m_preview) {
        setRecordNavigatorVisible(m_data);
        recordNavigator()->setEnabled(m_data);
        if (m_data) {
            recordNavigator()->setEditingIndicatorEnabled( !isReadOnly() );
            recordNavigator()->showEditingIndicator(false);
        }
 
        dbFormWidget()->updateReadOnlyFlags();
    }
}
 
KexiTableViewColumn* KexiFormScrollView::column(int col)
{
    const int id = fieldNumberForColumn(col);
    return (id >= 0) ? m_data->column( id ) : 0;
}
 
bool KexiFormScrollView::shouldDisplayDefaultValueForItem(KexiFormDataItemInterface* itemIface) const
{
    return cursorAtNewRow()
        && !itemIface->columnInfo()->field->defaultValue().isNull() 
//??        && (m_editor ? m_editor->value()==itemIface->columnInfo()->field->defaultValue() : true)
        && !itemIface->columnInfo()->field->isAutoIncrement(); // default value defined
}
 
bool KexiFormScrollView::cancelEditor()
{
    if (!dynamic_cast<KexiFormDataItemInterface*>(m_editor))
        return false;
 
    if (m_errorMessagePopup)
        m_errorMessagePopup->close();
 
    KexiFormDataItemInterface *itemIface = dynamic_cast<KexiFormDataItemInterface*>(m_editor);
    itemIface->undoChanges();
 
    const bool displayDefaultValue = shouldDisplayDefaultValueForItem(itemIface);
    // now disable/enable "display default value" if needed (do it after setValue(), before setValue() turns it off)
    if (itemIface->hasDisplayedDefaultValue() != displayDefaultValue)
        itemIface->setDisplayDefaultValue( dynamic_cast<TQWidget*>(itemIface), displayDefaultValue );
 
    fillDuplicatedDataItems(itemIface, m_editor->value());
 
    // this will clear editor pointer and close message popup (if present)
    return KexiDataAwareObjectInterface::cancelEditor();
}
 
void KexiFormScrollView::updateAfterCancelRowEdit()
{
    for (TQPtrListIterator<KexiFormDataItemInterface> it(m_dataItems); it.current(); ++it) {
        if (dynamic_cast<TQWidget*>(it.current())) {
            kexipluginsdbg << "KexiFormScrollView::updateAfterCancelRowEdit(): "
                << dynamic_cast<TQWidget*>(it.current())->className() << " " 
                << dynamic_cast<TQWidget*>(it.current())->name() << endl;
        }
        KexiFormDataItemInterface *itemIface = it.current();
        const bool displayDefaultValue = shouldDisplayDefaultValueForItem(itemIface);
        itemIface->undoChanges();
        if (itemIface->hasDisplayedDefaultValue() != displayDefaultValue)
            itemIface->setDisplayDefaultValue( dynamic_cast<TQWidget*>(itemIface), displayDefaultValue );
    }
    recordNavigator()->showEditingIndicator(false);
    dbFormWidget()->editedItem = 0;
}
 
void KexiFormScrollView::updateAfterAcceptRowEdit()
{
    if (!m_currentItem)
        return;
    recordNavigator()->showEditingIndicator(false);
    dbFormWidget()->editedItem = 0;
    //update visible data because there could be auto-filled (eg. autonumber) fields
    fillDataItems(*m_currentItem, cursorAtNewRow());
    m_previousItem = m_currentItem;
}
 
void KexiFormScrollView::beforeSwitchView()
{
    m_editor = 0;
}
 
void KexiFormScrollView::refreshContentsSize()
{
    KexiScrollView::refreshContentsSize();
    //only clear cmd history when KexiScrollView::refreshContentsSizeLater() has been called
    if (!m_preview && sender()==&m_delayedResize) {
        if (m_form)
            m_form->clearCommandHistory();
    }
}
 
void KexiFormScrollView::handleDataWidgetAction(const TQString& actionName)
{
    TQWidget *w = focusWidget();
    KexiFormDataItemInterface *item = 0;
    while (w) {
        item = dynamic_cast<KexiFormDataItemInterface*>(w);
        if (item)
            break;
        w = w->parentWidget();
    }
    if (item)
        item->handleAction(actionName);
}
 
void KexiFormScrollView::copySelection()
{
    handleDataWidgetAction("edit_copy");
}
 
void KexiFormScrollView::cutSelection()
{
    handleDataWidgetAction("edit_cut");
}
 
void KexiFormScrollView::paste()
{
    handleDataWidgetAction("edit_paste");
}
 
int KexiFormScrollView::lastVisibleRow() const
{
    return -1;
}
 
#include "kexiformscrollview.moc"