kexiactionselectiondialog.cpp

/* This file is part of the KDE project
   Copyright (C) 2005-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 "kexiactionselectiondialog.h"
#include "kexiactionselectiondialog_p.h"
 
#include <keximainwindow.h>
#include <kexipartitem.h>
#include <kexiproject.h>
#include <kexipartinfo.h>
#include <kexipart.h>
#include <kexiactioncategories.h>
 
#include <tdelistview.h>
#include <tdeaction.h>
#include <kiconloader.h>
#include <kdebug.h>
#include <kstdguiitem.h>
#include <kpushbutton.h>
 
#include <tqbitmap.h>
#include <tqlabel.h>
#include <tqheader.h>
#include <tqvbox.h>
#include <tqtooltip.h>
#include <tqwidgetstack.h>
 
#include <widget/utils/tdelistviewitemtemplate.h>
#include <widget/kexibrowser.h>
#include <widget/kexibrowseritem.h>
#include <kexiutils/utils.h>
 
typedef TDEListViewItemTemplate<TQString> ActionSelectorDialogListItemBase;
 
class ActionSelectorDialogListItem : public ActionSelectorDialogListItemBase
{
public:
    ActionSelectorDialogListItem(const TQString& data, TQListView *parent, TQString label1)
     : ActionSelectorDialogListItemBase(data, parent, label1)
     , fifoSorting(true)
    {
        m_sortKey.sprintf("%2.2d", parent->childCount());
    }
 
    ActionSelectorDialogListItem(const TQString& data, TQListViewItem *parent, TQString label1)
     : ActionSelectorDialogListItemBase(data, parent, label1)
     , fifoSorting(true)
    {
        m_sortKey.sprintf("%2.2d", parent->childCount());
    }
 
    virtual TQString key( int column, bool ascending ) const
    {
        return fifoSorting ? m_sortKey : ActionSelectorDialogListItemBase::key(column, ascending);
    }
 
    bool fifoSorting : 1;
 
protected:
    TQString m_sortKey;
};
 
//---------------------------------------
 
ActionsListViewBase::ActionsListViewBase(TQWidget* parent)
 : TDEListView(parent)
{
    setResizeMode(TQListView::AllColumns);
    addColumn("");
    header()->hide();
    setColumnWidthMode(0, TQListView::Maximum);
    setAllColumnsShowFocus(true);
    setTooltipColumn(0);
}
 
ActionsListViewBase::~ActionsListViewBase()
{
}
 
TQListViewItem *ActionsListViewBase::itemForAction(const TQString& actionName)
{
    for (TQListViewItemIterator it(this); it.current(); ++it) {
        ActionSelectorDialogListItem* item = dynamic_cast<ActionSelectorDialogListItem*>(it.current());
        if (item && item->data == actionName)
            return item;
    }
    return 0;
}
 
void ActionsListViewBase::selectAction(const TQString& actionName)
{
    TQListViewItem *item = itemForAction(actionName);
    if (item) {
        setSelected(item, true);
        ensureItemVisible(firstChild());
        ensureItemVisible(selectedItem());
    }
}
 
//---------------------------------------
 
TDEActionsListViewBase::TDEActionsListViewBase(TQWidget* parent, KexiMainWindow* mainWin)
    : ActionsListViewBase(parent)
    , m_mainWin(mainWin)
{
}
 
TDEActionsListViewBase::~TDEActionsListViewBase() {}
 
void TDEActionsListViewBase::init()
{
    setSorting(0);
    const TQPixmap noIcon( KexiUtils::emptyIcon(TDEIcon::Small) );
    TDEActionPtrList sharedActions( m_mainWin->allActions() );
    const Kexi::ActionCategories *acat = Kexi::actionCategories();
    foreach (TDEActionPtrList::ConstIterator, it, sharedActions) {
//          kdDebug() << (*it)->name() << " " << (*it)->text() << endl;
        const int actionCategories = acat->actionCategories((*it)->name());
        if (actionCategories==-1) {
            kexipluginswarn << "TDEActionsListViewBase(): no category declared for action \"" 
                << (*it)->name() << "\"! Fix this!" << endl;
            continue;
        }
        if (!isActionVisible((*it)->name(), actionCategories))
            continue;
        ActionSelectorDialogListItem *pitem = new ActionSelectorDialogListItem((*it)->name(), 
            this, (*it)->toolTip().isEmpty() ? (*it)->text().replace("&", "") : (*it)->toolTip() );
        pitem->fifoSorting = false; //alpha sort
        pitem->setPixmap( 0, (*it)->iconSet( TDEIcon::Small, 16 ).pixmap( TQIconSet::Small, TQIconSet::Active ) );
        if (!pitem->pixmap(0) || pitem->pixmap(0)->isNull())
            pitem->setPixmap( 0, noIcon );
    }
}
 
//---------------------------------------

class TDEActionsListView : public TDEActionsListViewBase
{
public:
    TDEActionsListView(TQWidget* parent, KexiMainWindow* mainWin)
        : TDEActionsListViewBase(parent, mainWin)
    {
    }
    virtual ~TDEActionsListView() {}
 
    virtual bool isActionVisible(const char* actionName, int actionCategories) const {
        Q_UNUSED(actionName);
        return actionCategories & Kexi::GlobalActionCategory;
    }
};

class CurrentFormActionsListView : public TDEActionsListViewBase
{
public:
    CurrentFormActionsListView(TQWidget* parent, KexiMainWindow* mainWin)
        : TDEActionsListViewBase(parent, mainWin)
    {
    }
    virtual ~CurrentFormActionsListView() {}
 
    virtual bool isActionVisible(const char* actionName, int actionCategories) const {
        return actionCategories & Kexi::WindowActionCategory
                && Kexi::actionCategories()->actionSupportsObjectType(actionName, KexiPart::FormObjectType);
    }
};

class ActionCategoriesListView : public ActionsListViewBase
{
public:
    ActionCategoriesListView(TQWidget* parent) //, KexiProject& project)
     : ActionsListViewBase(parent)
    {
        TQListViewItem *item = new ActionSelectorDialogListItem("noaction", this, i18n("No action") );
        const TQPixmap noIcon( KexiUtils::emptyIcon(TDEIcon::Small) );
        item->setPixmap(0, noIcon);
        item = new ActionSelectorDialogListItem("tdeaction", this, i18n("Application actions") );
        item->setPixmap(0, SmallIcon("form_action"));
 
        KexiPart::PartInfoList *pl = Kexi::partManager().partInfoList();
        for (KexiPart::Info *info = pl->first(); info; info = pl->next()) {
            KexiPart::Part *part = Kexi::partManager().part(info);
            if (!info->isVisibleInNavigator() || !part)
                continue;
            item = new KexiBrowserItem(this, info);
            item->setText(0, part->instanceCaption());
        }
        TQListViewItem *formItem = itemForAction("form");
        if (formItem) {
            item = new ActionSelectorDialogListItem("currentForm", formItem, 
                i18n("Current form's actions", "Current"));
        }
        adjustColumn(0);
        setMinimumWidth( columnWidth(0) + 6 );
    }
 
    ~ActionCategoriesListView()
    {
    }

    virtual TQListViewItem *itemForAction(const TQString& actionName)
    {
        for (TQListViewItemIterator it(this); it.current(); ++it) {
            //simple case
            ActionSelectorDialogListItem* item = dynamic_cast<ActionSelectorDialogListItem*>(it.current());
            if (item) {
                if (item->data == actionName)
                    return it.current();
                continue;
            }
            KexiBrowserItem* bitem = dynamic_cast<KexiBrowserItem*>(it.current());
            if (bitem) {
                if (bitem->info()->objectName() == actionName)
                    return it.current();
            }
        }
        return 0;
    }
};

class ActionToExecuteListView : public ActionsListViewBase
{
    public:
        ActionToExecuteListView(TQWidget* parent)
         : ActionsListViewBase(parent)
        {
        }
 
        ~ActionToExecuteListView()
        {
        }

        void showActionsForMimeType(const TQString& mimeType) {
            if (m_currentMimeType == mimeType)
                return;
            m_currentMimeType = mimeType;
            clear();
            KexiPart::Part *part = Kexi::partManager().partForMimeType( m_currentMimeType );
            if (!part)
                return;
            int supportedViewModes = part->supportedViewModes();
            ActionSelectorDialogListItem *item;
            const TQPixmap noIcon( KexiUtils::emptyIcon(TDEIcon::Small) );
            if (supportedViewModes & Kexi::DataViewMode) {
                item = new ActionSelectorDialogListItem("open", this, i18n("Open in Data View"));
                item->setPixmap(0, SmallIcon("document-open"));
            }
            if (part->info()->isExecuteSupported()) {
                item = new ActionSelectorDialogListItem("execute", this, i18n("Execute"));
                item->setPixmap(0, SmallIcon("media-playback-start"));
            }
            if (part->info()->isPrintingSupported()) {
                ActionSelectorDialogListItem *printItem = new ActionSelectorDialogListItem(
                    "print", this, i18n("Print"));
                printItem->setPixmap(0, SmallIcon("document-print"));
                TDEAction *a = KStdAction::printPreview(0, 0, 0);
                item = new ActionSelectorDialogListItem("printPreview", printItem, 
                    a->text().replace("&", "").replace("...", ""));
                item->setPixmap(0, SmallIcon(a->icon()));
                delete a;
                item = new ActionSelectorDialogListItem("pageSetup", printItem, i18n("Show Page Setup"));
                item->setPixmap(0, noIcon);
                setOpen(printItem, true);
                printItem->setExpandable(false);
            }
            if (part->info()->isDataExportSupported()) {
                ActionSelectorDialogListItem *exportItem = new ActionSelectorDialogListItem(
                    "exportToCSV", this, 
                    i18n("Note: use multiple rows if needed", "Export to File\nAs Data Table"));
                exportItem->setMultiLinesEnabled(true);
                exportItem->setPixmap(0, SmallIcon("table"));
                item = new ActionSelectorDialogListItem("copyToClipboardAsCSV", 
                    exportItem, 
                    i18n("Note: use multiple rows if needed", "Copy to Clipboard\nAs Data Table"));
                item->setPixmap(0, SmallIcon("table"));
                item->setMultiLinesEnabled(true);
                setOpen(exportItem, true);
                exportItem->setExpandable(false);
            }
            item = new ActionSelectorDialogListItem("new", this, i18n("Create New Object"));
            item->setPixmap(0, SmallIcon("document-new"));
            if (supportedViewModes & Kexi::DesignViewMode) {
                item = new ActionSelectorDialogListItem("design", this, i18n("Open in Design View"));
                item->setPixmap(0, SmallIcon("edit"));
            }
            if (supportedViewModes & Kexi::TextViewMode) {
                item = new ActionSelectorDialogListItem("editText", this, i18n("Open in Text View"));
                item->setPixmap(0, noIcon);
            }
            item = new ActionSelectorDialogListItem("close", this, i18n("Close View"));
            item->setPixmap(0, SmallIcon("window-close"));
            updateWidth();
        }
 
        void updateWidth()
        {
            adjustColumn(0);
            setMinimumWidth( columnWidth(0) );
        }
 
        TQString m_currentMimeType;
};
 
//-------------------------------------

class KexiActionSelectionDialog::KexiActionSelectionDialogPrivate
{
public:
    KexiActionSelectionDialogPrivate() 
        : tdeactionPageWidget(0), tdeactionListView(0), objectsListView(0)
        , currentFormActionsPageWidget(0)
        , currentFormActionsListView(0)
        , secondAnd3rdColumnMainWidget(0)
        , hideActionToExecuteListView(false)
    {
    }
 
    void raiseWidget(TQWidget *w)
    {
        secondAnd3rdColumnStack->raiseWidget( w );
        selectActionToBeExecutedLbl->setBuddy(w);
    }
 
    void updateSelectActionToBeExecutedMessage(const TQString& actionType)
    {
        TQString msg;
        if (actionType=="noaction")
            msg = TQString();
        // hardcoded, but it's not that bad
        else if (actionType=="macro")
            msg = i18n("&Select macro to be executed after clicking \"%1\" button:").arg(actionWidgetName);
        else if (actionType=="script")
            msg = i18n("&Select script to be executed after clicking \"%1\" button:").arg(actionWidgetName);
        //default: table/query/form/report...
        else
            msg = i18n("&Select object to be opened after clicking \"%1\" button:").arg(actionWidgetName);
        selectActionToBeExecutedLbl->setText(msg);
    }
 
    // changes 3rd column visibility
    void setActionToExecuteSectionVisible(bool visible, bool force = false)
    {
        if (!force && hideActionToExecuteListView != visible)
            return;
        hideActionToExecuteListView = !visible;
        actionToExecuteListView->hide();
        actionToExecuteLbl->hide();
        actionToExecuteListView->show();
        actionToExecuteLbl->show();
    }
 
    KexiMainWindow* mainWin;
    TQString actionWidgetName;
    ActionCategoriesListView* actionCategoriesListView; 
    TQWidget *tdeactionPageWidget;
    TDEActionsListView* tdeactionListView;  
    KexiBrowser* objectsListView; 
    TQWidget *currentFormActionsPageWidget; 
    CurrentFormActionsListView* currentFormActionsListView; 
    TQWidget *emptyWidget;
    TQLabel* selectActionToBeExecutedLbl;
    ActionToExecuteListView* actionToExecuteListView;
    TQLabel *actionToExecuteLbl;
    TQWidget *secondAnd3rdColumnMainWidget;
    TQGridLayout *glyr;
    TQGridLayout *secondAnd3rdColumnGrLyr;
    TQWidgetStack *secondAnd3rdColumnStack, *secondColumnStack;
    bool hideActionToExecuteListView;
};
 
//-------------------------------------
 
KexiActionSelectionDialog::KexiActionSelectionDialog(KexiMainWindow* mainWin, TQWidget *parent, 
    const KexiFormEventAction::ActionData& action, const TQCString& actionWidgetName)
    : KDialogBase(parent, "actionSelectorDialog", true, i18n("Assigning Action to Command Button"), 
        KDialogBase::Ok | KDialogBase::Cancel )
    , d( new KexiActionSelectionDialogPrivate() )
{
    d->mainWin = mainWin;
    d->actionWidgetName = actionWidgetName;
    setButtonOK( KGuiItem(i18n("Assign action", "&Assign"), "button_ok", i18n("Assign action")) );
 
    TQWidget *mainWidget = new TQWidget( this );
    mainWidget->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum);
    setMainWidget(mainWidget);
 
/*    lbl 1
   +------------+ +-------------------------------+
   |            | |              [a]              |
   | 1st column | | +----------- + +------------+ |
   |            | | | 2nd column | | 3rd column | |
   |            | | +            + +            + |
   |            | | +------------+ +------------+ |
   +------------+ +-------------------------------+
   \______________________________________________/
                        glyr
  [a]- TQWidgetStack *secondAnd3rdColumnStack, 
    - for displaying TDEActions, the stack contains d->tdeactionPageWidget TQWidget
    - for displaying objects, the stack contains secondAnd3rdColumnMainWidget TQWidget and TQGridLayout *secondAnd3rdColumnGrLyr
     - tdeactionPageWidget contains only a TQVBoxLayout and label+tdeactionListView
*/
    d->glyr = new TQGridLayout(mainWidget, 2, 2, KDialog::marginHint(), KDialog::spacingHint());
    d->glyr->setRowStretch(1, 1);
 
    // 1st column: action types
    d->actionCategoriesListView = new ActionCategoriesListView(mainWidget);
    d->actionCategoriesListView->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Minimum);
    d->glyr->addWidget(d->actionCategoriesListView, 1, 0);
    connect( d->actionCategoriesListView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), 
        this, TQ_SLOT(slotActionCategorySelected(TQListViewItem*)));
 
    TQLabel *lbl = new TQLabel(d->actionCategoriesListView, i18n("Action category:"), mainWidget);
    lbl->setMinimumHeight(lbl->fontMetrics().height()*2);
    lbl->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Fixed);
    lbl->setAlignment(TQt::AlignTop|TQt::AlignLeft|TQt::WordBreak);
    d->glyr->addWidget(lbl, 0, 0, TQt::AlignTop|TQt::AlignLeft);
    
    // widget stack for 2nd and 3rd column
    d->secondAnd3rdColumnStack = new TQWidgetStack(mainWidget);
    d->secondAnd3rdColumnStack->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum);
    d->glyr->addMultiCellWidget(d->secondAnd3rdColumnStack, 0, 1, 1, 1);//, TQt::AlignTop|TQt::AlignLeft);
 
    d->secondAnd3rdColumnMainWidget = new TQWidget(d->secondAnd3rdColumnStack);
    d->secondAnd3rdColumnMainWidget->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum);
    d->secondAnd3rdColumnGrLyr = new TQGridLayout(d->secondAnd3rdColumnMainWidget, 2, 2, 0, KDialog::spacingHint());
    d->secondAnd3rdColumnGrLyr->setRowStretch(1, 2);
    d->secondAnd3rdColumnStack->addWidget(d->secondAnd3rdColumnMainWidget);
 
    // 2nd column: list of actions/objects
    d->objectsListView = new KexiBrowser(d->secondAnd3rdColumnMainWidget, d->mainWin, 0/*features*/);
    d->secondAnd3rdColumnGrLyr->addWidget(d->objectsListView, 1, 0);
    connect(d->objectsListView, TQ_SIGNAL(selectionChanged(KexiPart::Item*)),
        this, TQ_SLOT(slotItemForOpeningOrExecutingSelected(KexiPart::Item*)));
 
    d->selectActionToBeExecutedLbl = new TQLabel(d->secondAnd3rdColumnMainWidget);
    d->selectActionToBeExecutedLbl->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed);
    d->selectActionToBeExecutedLbl->setAlignment(TQt::AlignTop|TQt::AlignLeft|TQt::WordBreak);
    d->selectActionToBeExecutedLbl->setMinimumHeight(d->selectActionToBeExecutedLbl->fontMetrics().height()*2);
    d->secondAnd3rdColumnGrLyr->addWidget(d->selectActionToBeExecutedLbl, 0, 0, TQt::AlignTop|TQt::AlignLeft);
 
    d->emptyWidget = new TQWidget(d->secondAnd3rdColumnStack);
    d->secondAnd3rdColumnStack->addWidget(d->emptyWidget);
 
    // 3rd column: actions to execute
    d->actionToExecuteListView = new ActionToExecuteListView(d->secondAnd3rdColumnMainWidget);
    d->actionToExecuteListView->installEventFilter(this); //to be able to disable painting
    d->actionToExecuteListView->viewport()->installEventFilter(this); //to be able to disable painting
    d->actionToExecuteListView->setSizePolicy(TQSizePolicy::Fixed, TQSizePolicy::Minimum);
    connect(d->actionToExecuteListView, TQ_SIGNAL(executed(TQListViewItem*)),
        this, TQ_SLOT(slotActionToExecuteItemExecuted(TQListViewItem*)));
    connect(d->actionToExecuteListView, TQ_SIGNAL(selectionChanged(TQListViewItem*)),
        this, TQ_SLOT(slotActionToExecuteItemSelected(TQListViewItem*)));
    d->secondAnd3rdColumnGrLyr->addWidget(d->actionToExecuteListView, 1, 1);
 
    d->actionToExecuteLbl = new TQLabel(d->actionToExecuteListView, 
        i18n("Action to execute:"), d->secondAnd3rdColumnMainWidget);
    d->actionToExecuteLbl->installEventFilter(this); //to be able to disable painting
    d->actionToExecuteLbl->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Fixed);
    d->actionToExecuteLbl->setAlignment(TQt::AlignTop|TQt::AlignLeft|TQt::WordBreak);
    d->secondAnd3rdColumnGrLyr->addWidget(d->actionToExecuteLbl, 0, 1, TQt::AlignTop|TQt::AlignLeft);
 
    // temporary show all sections to avoid resizing the dialog in the future
    d->actionCategoriesListView->selectAction("table");
    d->setActionToExecuteSectionVisible(true);
    adjustSize();
    resize(TQMAX(700, width()), TQMAX(450, height()));
    d->actionToExecuteListView->updateWidth();
 
    bool ok;
    TQString actionType, actionArg;
    KexiPart::Info* partInfo = action.decodeString(actionType, actionArg, ok);
    if (ok) {
        d->actionCategoriesListView->selectAction(actionType);
        if (actionType=="tdeaction") {
            d->tdeactionListView->selectAction(actionArg);
            d->tdeactionListView->setFocus();
        }
        else if (actionType=="currentForm") {
            d->currentFormActionsListView->selectAction(actionArg);
            d->currentFormActionsListView->setFocus();
        }
        else if (partInfo
            && Kexi::partManager().part(partInfo)) // We use the Part Manager
            // to determine whether the Kexi-plugin is installed and whether we like to show 
            // it in our list of actions.
        {
            KexiPart::Item *item = d->mainWin->project()->item(partInfo, actionArg);
            if (d->objectsListView && item) {
                d->objectsListView->selectItem(*item);
                TQString actionOption( action.option );
                if (actionOption.isEmpty())
                    actionOption = "open"; // for backward compatibility
                d->actionToExecuteListView->selectAction(actionOption);
                d->objectsListView->setFocus();
            }
        }
    }
    else {//invalid assignment or 'noaction'
        d->actionCategoriesListView->selectAction("noaction");
        d->actionCategoriesListView->setFocus();
    }
}
 
KexiActionSelectionDialog::~KexiActionSelectionDialog()
{
    delete d;
}
 
void KexiActionSelectionDialog::slotTDEActionItemExecuted(TQListViewItem*)
{
    accept();
}
 
void KexiActionSelectionDialog::slotTDEActionItemSelected(TQListViewItem*)
{
    d->setActionToExecuteSectionVisible(false);
    updateOKButtonStatus();
}
 
void KexiActionSelectionDialog::slotCurrentFormActionItemExecuted(TQListViewItem*)
{
    accept();
}
 
void KexiActionSelectionDialog::slotCurrentFormActionItemSelected(TQListViewItem*)
{
    d->setActionToExecuteSectionVisible(false);
    updateOKButtonStatus();
}
 
void KexiActionSelectionDialog::slotItemForOpeningOrExecutingSelected(KexiPart::Item* item)
{
    d->setActionToExecuteSectionVisible(item);
}
 
void KexiActionSelectionDialog::slotActionToExecuteItemExecuted(TQListViewItem* item)
{
    if (!item)
        return;
    ActionSelectorDialogListItemBase *listItem = dynamic_cast<ActionSelectorDialogListItemBase*>(item);
    if (listItem && !listItem->data.isEmpty())
        accept();
}
 
void KexiActionSelectionDialog::slotActionToExecuteItemSelected(TQListViewItem*)
{
    updateOKButtonStatus();
}
 
void KexiActionSelectionDialog::slotActionCategorySelected(TQListViewItem* item)
{
    ActionSelectorDialogListItem *simpleItem = dynamic_cast<ActionSelectorDialogListItem*>(item);
    // simple case: part-less item, e.g. tdeaction:
    if (simpleItem) {
        d->updateSelectActionToBeExecutedMessage(simpleItem->data);
        TQString selectActionToBeExecutedMsg(
            i18n("&Select action to be executed after clicking \"%1\" button:")); // msg for a label
        if (simpleItem->data == "tdeaction") {
            if (!d->tdeactionPageWidget) {
                //create lbl+list view with a vlayout
                d->tdeactionPageWidget = new TQWidget();
                d->tdeactionPageWidget->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum);
                TQVBoxLayout *vlyr = new TQVBoxLayout(d->tdeactionPageWidget, 0, KDialog::spacingHint());
                d->tdeactionListView = new TDEActionsListView(d->tdeactionPageWidget, d->mainWin);
                d->tdeactionListView->init();
                TQLabel *lbl = new TQLabel(d->tdeactionListView, selectActionToBeExecutedMsg.arg(d->actionWidgetName),
                    d->tdeactionPageWidget);
                lbl->setAlignment(TQt::AlignTop|TQt::AlignLeft|TQt::WordBreak);
                lbl->setMinimumHeight(lbl->fontMetrics().height()*2);
                vlyr->addWidget(lbl);
                vlyr->addWidget(d->tdeactionListView);
                d->secondAnd3rdColumnStack->addWidget(d->tdeactionPageWidget);
                connect(d->tdeactionListView, TQ_SIGNAL(executed(TQListViewItem*)),
                    this, TQ_SLOT(slotTDEActionItemExecuted(TQListViewItem*)));
                connect( d->tdeactionListView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), 
                    this, TQ_SLOT(slotTDEActionItemSelected(TQListViewItem*)));
            }
            d->setActionToExecuteSectionVisible(false);
            d->raiseWidget(d->tdeactionPageWidget);
            slotTDEActionItemSelected(d->tdeactionListView->selectedItem()); //to refresh column #3
        }
        else if (simpleItem->data == "currentForm") {
            if (!d->currentFormActionsPageWidget) {
                //create lbl+list view with a vlayout
                d->currentFormActionsPageWidget = new TQWidget();
                d->currentFormActionsPageWidget->setSizePolicy(TQSizePolicy::Minimum, TQSizePolicy::Minimum);
                TQVBoxLayout *vlyr = new TQVBoxLayout(d->currentFormActionsPageWidget, 0, KDialog::spacingHint());
                d->currentFormActionsListView = new CurrentFormActionsListView(
                    d->currentFormActionsPageWidget, d->mainWin);
                d->currentFormActionsListView->init();
                TQLabel *lbl = new TQLabel(d->currentFormActionsListView, 
                    selectActionToBeExecutedMsg.arg(d->actionWidgetName), d->currentFormActionsPageWidget);
                lbl->setAlignment(TQt::AlignTop|TQt::AlignLeft|TQt::WordBreak);
                lbl->setMinimumHeight(lbl->fontMetrics().height()*2);
                vlyr->addWidget(lbl);
                vlyr->addWidget(d->currentFormActionsListView);
                d->secondAnd3rdColumnStack->addWidget(d->currentFormActionsPageWidget);
                connect(d->currentFormActionsListView, TQ_SIGNAL(executed(TQListViewItem*)),
                    this, TQ_SLOT(slotCurrentFormActionItemExecuted(TQListViewItem*)));
                connect( d->currentFormActionsListView, TQ_SIGNAL(selectionChanged(TQListViewItem*)), 
                    this, TQ_SLOT(slotCurrentFormActionItemSelected(TQListViewItem*)));
            }
            d->setActionToExecuteSectionVisible(false);
            d->raiseWidget(d->currentFormActionsPageWidget);
            slotCurrentFormActionItemSelected(d->currentFormActionsListView->selectedItem()); //to refresh column #3
        }
        else if (simpleItem->data == "noaction") {
            d->raiseWidget(d->emptyWidget);
            d->objectsListView->clearSelection();
            //hide column #3
            d->setActionToExecuteSectionVisible(false);
        }
        d->actionCategoriesListView->update();
        updateOKButtonStatus();
        return;
    }
    // other case
    KexiBrowserItem* browserItem = dynamic_cast<KexiBrowserItem*>(item);
    if (browserItem) {
        d->updateSelectActionToBeExecutedMessage(browserItem->info()->objectName());
        if (d->objectsListView->itemsMimeType().latin1()!=browserItem->info()->mimeType()) {
            d->objectsListView->setProject(d->mainWin->project(), browserItem->info()->mimeType());
            d->actionToExecuteListView->showActionsForMimeType( browserItem->info()->mimeType() );
            d->setActionToExecuteSectionVisible(false);
        }
        if (d->secondAnd3rdColumnStack->visibleWidget()!=d->secondAnd3rdColumnMainWidget) {
            d->raiseWidget( d->secondAnd3rdColumnMainWidget );
            d->objectsListView->clearSelection();
            d->setActionToExecuteSectionVisible(false, true);
        }
        else
            d->raiseWidget( d->secondAnd3rdColumnMainWidget );
    }
    d->actionCategoriesListView->update();
    updateOKButtonStatus();
}
 
KexiMainWindow* KexiActionSelectionDialog::mainWin() const
{
    return d->mainWin;
}
 
KexiFormEventAction::ActionData KexiActionSelectionDialog::currentAction() const
{
    KexiFormEventAction::ActionData data;
    ActionSelectorDialogListItem *simpleItem = dynamic_cast<ActionSelectorDialogListItem*>(
        d->actionCategoriesListView->selectedItem());
    // simple case: part-less item, e.g. tdeaction:
    if (simpleItem) {
        if (simpleItem->data == "tdeaction") {
            if (d->tdeactionListView->selectedItem()) {
                data.string = TQString("tdeaction:")
                    + dynamic_cast<ActionSelectorDialogListItem*>( d->tdeactionListView->selectedItem() )->data;
                return data;
            }
        }
        else if (simpleItem->data == "currentForm") {
            if (d->currentFormActionsListView->selectedItem()) {
                data.string = TQString("currentForm:")
                    + dynamic_cast<ActionSelectorDialogListItem*>( 
                        d->currentFormActionsListView->selectedItem() )->data;
                return data;
            }
        }
    }
    KexiBrowserItem* browserItem = dynamic_cast<KexiBrowserItem*>( d->actionCategoriesListView->selectedItem() );
    if (browserItem) {
        ActionSelectorDialogListItem *actionToExecute = dynamic_cast<ActionSelectorDialogListItem*>(
            d->actionToExecuteListView->selectedItem());
        if (d->objectsListView && actionToExecute && !actionToExecute->data.isEmpty()) {
            KexiPart::Item* partItem = d->objectsListView->selectedPartItem();
            KexiPart::Info* partInfo = partItem ? Kexi::partManager().infoForMimeType( partItem->mimeType() ) : 0;
            if (partInfo) {
                // opening or executing: table:name, query:name, form:name, macro:name, script:name, etc.
                data.string = TQString("%1:%2").arg(partInfo->objectName()).arg(partItem->name());
                data.option = actionToExecute->data;
                return data;
            }
        }
    }
    return data; // No Action
}
 
void KexiActionSelectionDialog::updateOKButtonStatus()
{
    TQPushButton *btn = actionButton(Ok);
    ActionSelectorDialogListItem *simpleItem = dynamic_cast<ActionSelectorDialogListItem*>(
        d->actionCategoriesListView->selectedItem());
    btn->setEnabled( (simpleItem && simpleItem->data == "noaction") || !currentAction().isEmpty() );
}
 
bool KexiActionSelectionDialog::eventFilter(TQObject *o, TQEvent *e)
{
    if (d->hideActionToExecuteListView)
        return true;
    return KDialogBase::eventFilter(o, e);
}
 
#include "kexiactionselectiondialog.moc"
#include "kexiactionselectiondialog_p.moc"