/* This file is part of the KDE project Copyright (C) 2005-2006 Raphael Langerhorst <raphael.langerhorst@kdemail.net> (C) 2006 Stefan Nikolaus <stefan.nikolaus@kdemail.net> (C) 2002-2005 Ariya Hidayat <ariya@kde.org> (C) 1999-2003 Laurent Montel <montel@kde.org> (C) 2002-2003 Norbert Andres <nandres@web.de> (C) 2002-2003 Philipp Mueller <philipp.mueller@gmx.de> (C) 2002-2003 John Dailey <dailey@vt.edu> (C) 1999-2003 David Faure <faure@kde.org> (C) 1999-2001 Simon Hausmann <hausmann@kde.org> (C) 1998-2000 Torben Weis <weis@kde.org> 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 <kprinter.h> // has to be first // standard C/C++ includes #include <assert.h> #include <stdlib.h> #include <time.h> // TQt includes #include <tqbuffer.h> #include <tqclipboard.h> #include <tqcursor.h> #include <tqlayout.h> #include <tqpaintdevicemetrics.h> #include <tqregexp.h> #include <tqtimer.h> #include <tqtoolbutton.h> #include <tqsqldatabase.h> #include <tqlistview.h> #include <tqsizepolicy.h> // KDE includes #include <dcopclient.h> #include <dcopref.h> #include <kapplication.h> #include <kconfig.h> #include <kdebug.h> #include <kfind.h> #include <kfinddialog.h> #include <kfontdialog.h> #include <kinputdialog.h> #include <kmessagebox.h> #include <knotifyclient.h> #include <kpassdlg.h> #include <kprocio.h> #include <kreplace.h> #include <kreplacedialog.h> #include <kspell.h> #include <kspelldlg.h> #include <kstatusbar.h> #include <kstdaction.h> #include <kstandarddirs.h> #include <ktempfile.h> #include <kparts/partmanager.h> #include <klistview.h> #include <kpushbutton.h> // KOffice includes #include <tkcoloractions.h> #include <kdatatool.h> #include <KoCharSelectDia.h> #include <KoCommandHistory.h> #include <KoMainWindow.h> #include <KoOasisLoadingContext.h> #include <KoOasisStore.h> #include <KoOasisStyles.h> #include <KoPartSelectAction.h> #include <KoStoreDrag.h> #include <KoTabBar.h> #include <kspread_toolbox.h> #include <KoTemplateCreateDia.h> #include <KoZoomAction.h> // KSpread includes #include "commands.h" #include "damages.h" #include "digest.h" #include "inspector.h" #include "ksploadinginfo.h" #include "kspread_canvas.h" #include "kspread_editors.h" #include "kspread_events.h" #include "kspread_global.h" #include "kspread_handler.h" #include "kspread_locale.h" #include "kspread_map.h" #include "selection.h" #include "kspread_sheetprint.h" #include "kspread_style.h" #include "kspread_style_manager.h" #include "kspread_undo.h" #include "testrunner.h" #include "valuecalc.h" #include "valueconverter.h" // dialogs #include "dialogs/kspread_dlg_angle.h" #include "dialogs/kspread_dlg_area.h" #include "dialogs/kspread_dlg_comment.h" #include "dialogs/kspread_dlg_conditional.h" #include "dialogs/kspread_dlg_cons.h" #include "dialogs/kspread_dlg_csv.h" #include "dialogs/kspread_dlg_database.h" #include "dialogs/kspread_dlg_format.h" #include "dialogs/kspread_dlg_formula.h" #include "dialogs/kspread_dlg_goalseek.h" #include "dialogs/kspread_dlg_goto.h" #include "dialogs/kspread_dlg_insert.h" #include "dialogs/kspread_dlg_layout.h" #include "dialogs/kspread_dlg_list.h" //#include "dialogs/kspread_dlg_multipleop.h" #include "dialogs/kspread_dlg_paperlayout.h" #include "dialogs/kspread_dlg_pasteinsert.h" #include "dialogs/kspread_dlg_preference.h" #include "dialogs/kspread_dlg_reference.h" #include "dialogs/kspread_dlg_resize2.h" #include "dialogs/kspread_dlg_series.h" #include "dialogs/kspread_dlg_show.h" #include "dialogs/kspread_dlg_showColRow.h" #include "dialogs/kspread_dlg_sort.h" #include "dialogs/kspread_dlg_special.h" #include "dialogs/kspread_dlg_styles.h" #include "dialogs/kspread_dlg_subtotal.h" #include "dialogs/kspread_dlg_validity.h" #include "dialogs/link.h" #include "dialogs/sheet_properties.h" #include "dialogs/kspread_dlg_find.h" #include "dialogs/SheetSelectWidget.h" #include "kspread_propertyEditor.h" #include "kspread_generalProperty.h" // KSpread DCOP #include "KSpreadViewIface.h" #include "kspread_view.h" namespace KSpread { class ViewActions; class View::Private { public: View* view; Doc* doc; DCOPObject* dcop; // the active sheet, may be 0 // this is the sheet which has the input focus Sheet* activeSheet; // GUI elements TQWidget *frame; TQFrame *toolWidget; Canvas *canvas; VBorder *vBorderWidget; HBorder *hBorderWidget; TQScrollBar *horzScrollBar; TQScrollBar *vertScrollBar; KoTabBar *tabBar; KStatusBarLabel* calcLabel; // formulabar, consists of: TQHBoxLayout* formulaBarLayout; ComboboxLocationEditWidget *posWidget; TQButton* formulaButton; TQButton *okButton; TQButton *cancelButton; KSpread::EditWidget *editWidget; TQGridLayout* viewLayout; TQHBoxLayout* tabScrollBarLayout; // all UI actions ViewActions* actions; // If updateEditWidget is called it changes some KToggleActions. // That causes them to emit a signal. If this lock is true, then these // signals are ignored. bool toolbarLock; // if true, kspread is still loading the document // don't try to refresh the view bool loading; // selection/marker Selection* selection; Selection* choice; TQMap<Sheet*, TQPoint> savedAnchors; TQMap<Sheet*, TQPoint> savedMarkers; TQMap<Sheet*, KoPoint> savedOffsets; // Find and Replace context. We remember the options and // the strings used previously. long findOptions; TQStringList findStrings; TQStringList replaceStrings; FindOption::searchTypeValue typeValue; FindOption::searchDirectionValue directionValue; // Current "find" operation KFind* find; KReplace* replace; int findLeftColumn; int findRightColumn; TQPoint findPos; TQPoint findEnd; InsertHandler* insertHandler; // Insert special character dialog KoCharSelectDia* specialCharDlg; // Holds a guarded pointer to the transformation toolbox. TQGuardedPtr<KoTransformToolBox> transformToolBox; // the last popup menu (may be 0). // Since only one popup menu can be opened at once, its pointer is stored here. // Delete the old one before you store a pointer to anotheron here. TQPopupMenu *popupMenu; int popupMenuFirstToolId; TQPopupMenu *popupRow; TQPopupMenu *popupColumn; TQPopupMenu* popupChild; // for embedded children TQPopupMenu* popupListChoose; // for list of choose // the child for which the popup menu has been opened. Child* popupChildObject; // spell-check context struct { KSpell * kspell; Sheet * firstSpellSheet; Sheet * currentSpellSheet; Cell * currentCell; MacroUndoAction *macroCmdSpellCheck; unsigned int spellCurrCellX; unsigned int spellCurrCellY; unsigned int spellStartCellX; unsigned int spellStartCellY; unsigned int spellEndCellX; unsigned int spellEndCellY; bool spellCheckSelection; TQStringList replaceAll; } spell; struct { Sheet * currentSheet; Sheet * firstSheet; } searchInSheets; // the tools struct ToolEntry { TQString command; KDataToolInfo info; }; TQPtrList<ToolEntry> toolList; void initActions(); void adjustActions( bool mode ); void adjustActions( Sheet* sheet, Cell* cell ); void adjustWorkbookActions( bool mode ); void updateButton( Cell *cell, int column, int row); TQButton* newIconButton( const char *_file, bool _kbutton = false, TQWidget *_parent = 0L ); PropertyEditor *m_propertyEditor; // On timeout this will execute the status bar operation (e.g. SUM). // This is delayed to speed up the selection. TQTimer statusBarOpTimer; }; class ViewActions { public: // cell formatting KAction* cellLayout; KAction *actionExtraProperties; KAction* defaultFormat; KToggleAction* bold; KToggleAction* italic; KToggleAction* underline; KToggleAction* strikeOut; KFontAction* selectFont; KFontSizeAction* selectFontSize; KAction* fontSizeUp; KAction* fontSizeDown; TKSelectColorAction* textColor; KToggleAction* alignLeft; KToggleAction* alignCenter; KToggleAction* alignRight; KToggleAction* alignTop; KToggleAction* alignMiddle; KToggleAction* alignBottom; KToggleAction* wrapText; KToggleAction* verticalText; KAction* increaseIndent; KAction* decreaseIndent; KAction* changeAngle; KToggleAction* percent; KAction* precplus; KAction* precminus; KToggleAction* money; KAction* upper; KAction* lower; KAction* firstLetterUpper; TKSelectColorAction* bgColor; KAction* borderLeft; KAction* borderRight; KAction* borderTop; KAction* borderBottom; KAction* borderAll; KAction* borderOutline; KAction* borderRemove; TKSelectColorAction* borderColor; KSelectAction* selectStyle; KAction* createStyle; // cell operations KAction* editCell; KAction* insertCell; KAction* removeCell; KAction* deleteCell; KToolBarPopupAction* mergeCell; KAction* mergeCellHorizontal; KAction* mergeCellVertical; KAction* dissociateCell; KAction* clearText; KAction* conditional; KAction* clearConditional; KAction* validity; KAction* clearValidity; KAction* addModifyComment; KAction* removeComment; KAction* clearComment; // column & row operations KAction* resizeColumn; KAction* insertColumn; KAction* deleteColumn; KAction* hideColumn; KAction* showColumn; KAction* equalizeColumn; KAction* showSelColumns; KAction* resizeRow; KAction* insertRow; KAction* deleteRow; KAction* hideRow; KAction* showRow; KAction* equalizeRow; KAction* showSelRows; KAction* adjust; // sheet/workbook operations KAction* sheetProperties; KAction* insertSheet; KAction* menuInsertSheet; KAction* removeSheet; KAction* renameSheet; KAction* hideSheet; KAction* showSheet; KAction* autoFormat; KAction* areaName; KAction* showArea; KAction* insertSeries; KAction* insertFunction; KAction* insertSpecialChar; KAction* insertFromDatabase; KAction* insertFromTextfile; KAction* insertFromClipboard; KAction* transform; KAction* sort; KAction* sortDec; KAction* sortInc; KAction* fillRight; KAction* fillLeft; KAction* fillUp; KAction* fillDown; KAction* paperLayout; KAction* definePrintRange; KAction* resetPrintRange; KToggleAction* showPageBorders; KAction* recalcWorksheet; KAction* recalcWorkbook; KToggleAction* protectSheet; KToggleAction* protectDoc; // general editing KAction* cut; KAction* copy; KAction* paste; KAction* specialPaste; KAction* insertCellCopy; KAction* find; KAction* replace; // navigation KAction* gotoCell; KAction* nextSheet; KAction* prevSheet; KAction* firstSheet; KAction* lastSheet; // misc KAction* styleDialog; KAction* autoSum; KSelectAction* formulaSelection; KAction* insertLink; KAction* removeLink; KAction* consolidate; KAction* goalSeek; KAction* subTotals; KAction* textToColumns; KAction* multipleOperations; KAction* createTemplate; KoPartSelectAction *insertPart; KToggleAction* insertChartFrame; KAction* insertPicture; KAction* customList; KAction* spellChecking; KAction* internalTests; KAction* inspector; // settings KoZoomAction* viewZoom; KToggleAction* showStatusBar; KToggleAction* showTabBar; KToggleAction* showFormulaBar; KAction* preference; // running calculation KToggleAction* calcNone; KToggleAction* calcMin; KToggleAction* calcMax; KToggleAction* calcAverage; KToggleAction* calcCount; KToggleAction* calcSum; KToggleAction* calcCountA; }; void View::Private::initActions() { actions = new ViewActions; KActionCollection* ac = view->actionCollection(); // -- cell formatting actions -- actions->cellLayout = new KAction( i18n("Cell Format..."), "cell_layout", TQt::CTRL+ TQt::ALT+ TQt::Key_F, TQT_TQOBJECT(view), TQT_SLOT( layoutDlg() ), ac, "cellLayout" ); actions->cellLayout->setToolTip( i18n("Set the cell formatting.") ); actions->actionExtraProperties = new KAction( i18n( "&Properties" ), "penbrush", 0, TQT_TQOBJECT(view), TQT_SLOT( extraProperties() ), ac, "extra_properties" ); actions->defaultFormat = new KAction( i18n("Default"), 0, TQT_TQOBJECT(view), TQT_SLOT( defaultSelection() ), ac, "default" ); actions->defaultFormat->setToolTip( i18n("Resets to the default format.") ); actions->bold = new KToggleAction( i18n("Bold"), "text_bold", TQt::CTRL+TQt::Key_B, ac, "bold"); TQT_BASE_OBJECT_NAME::connect( actions->bold, TQT_SIGNAL( toggled( bool) ), TQT_TQOBJECT(view), TQT_SLOT( bold( bool ) ) ); actions->italic = new KToggleAction( i18n("Italic"), "text_italic", TQt::CTRL+TQt::Key_I, ac, "italic"); TQT_BASE_OBJECT_NAME::connect( actions->italic, TQT_SIGNAL( toggled( bool) ), TQT_TQOBJECT(view), TQT_SLOT( italic( bool ) ) ); actions->underline = new KToggleAction( i18n("Underline"), "text_under", TQt::CTRL+TQt::Key_U, ac, "underline"); TQT_BASE_OBJECT_NAME::connect( actions->underline, TQT_SIGNAL( toggled( bool) ), TQT_TQOBJECT(view), TQT_SLOT( underline( bool ) ) ); actions->strikeOut = new KToggleAction( i18n("Strike Out"), "text_strike", 0, ac, "strikeout"); TQT_BASE_OBJECT_NAME::connect( actions->strikeOut, TQT_SIGNAL( toggled( bool) ), TQT_TQOBJECT(view), TQT_SLOT( strikeOut( bool ) ) ); actions->selectFont = new KFontAction( i18n("Select Font..."), 0, ac, "selectFont" ); TQT_BASE_OBJECT_NAME::connect( actions->selectFont, TQT_SIGNAL( activated( const TQString& ) ), TQT_TQOBJECT(view), TQT_SLOT( fontSelected( const TQString& ) ) ); actions->selectFontSize = new KFontSizeAction( i18n("Select Font Size"), 0, ac, "selectFontSize" ); TQT_BASE_OBJECT_NAME::connect( actions->selectFontSize, TQT_SIGNAL( fontSizeChanged( int ) ), TQT_TQOBJECT(view), TQT_SLOT( fontSizeSelected( int ) ) ); actions->fontSizeUp = new KAction( i18n("Increase Font Size"), "fontsizeup", 0, TQT_TQOBJECT(view), TQT_SLOT( increaseFontSize() ), ac, "increaseFontSize" ); actions->fontSizeDown = new KAction( i18n("Decrease Font Size"), "fontsizedown", 0, TQT_TQOBJECT(view), TQT_SLOT( decreaseFontSize() ), ac, "decreaseFontSize" ); actions->textColor = new TKSelectColorAction( i18n("Text Color"), TKSelectColorAction::TextColor, TQT_TQOBJECT(view), TQT_SLOT( changeTextColor() ), ac, "textColor",true ); actions->textColor->setDefaultColor(TQColor()); actions->alignLeft = new KToggleAction( i18n("Align Left"), "text_left", 0, ac, "left"); TQT_BASE_OBJECT_NAME::connect( actions->alignLeft, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignLeft( bool ) ) ); actions->alignLeft->setExclusiveGroup( "Align" ); actions->alignLeft->setToolTip(i18n("Left justify the cell contents.")); actions->alignCenter = new KToggleAction( i18n("Align Center"), "text_center", 0, ac, "center"); TQT_BASE_OBJECT_NAME::connect( actions->alignCenter, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignCenter( bool ) ) ); actions->alignCenter->setExclusiveGroup( "Align" ); actions->alignCenter->setToolTip(i18n("Center the cell contents.")); actions->alignRight = new KToggleAction( i18n("Align Right"), "text_right", 0, ac, "right"); TQT_BASE_OBJECT_NAME::connect( actions->alignRight, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignRight( bool ) ) ); actions->alignRight->setExclusiveGroup( "Align" ); actions->alignRight->setToolTip(i18n("Right justify the cell contents.")); actions->alignTop = new KToggleAction( i18n("Align Top"), "text_top", 0, ac, "top"); TQT_BASE_OBJECT_NAME::connect( actions->alignTop, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignTop( bool ) ) ); actions->alignTop->setExclusiveGroup( "Pos" ); actions->alignTop->setToolTip(i18n("Align cell contents along the top of the cell.")); actions->alignMiddle = new KToggleAction( i18n("Align Middle"), "middle", 0, ac, "middle"); TQT_BASE_OBJECT_NAME::connect( actions->alignMiddle, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignMiddle( bool ) ) ); actions->alignMiddle->setExclusiveGroup( "Pos" ); actions->alignMiddle->setToolTip(i18n("Align cell contents centered in the cell.")); actions->alignBottom = new KToggleAction( i18n("Align Bottom"), "text_bottom", 0, ac, "bottom"); TQT_BASE_OBJECT_NAME::connect( actions->alignBottom, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( alignBottom( bool ) ) ); actions->alignBottom->setExclusiveGroup( "Pos" ); actions->alignBottom->setToolTip(i18n("Align cell contents along the bottom of the cell.")); actions->wrapText = new KToggleAction( i18n("Wrap Text"), "multirow", 0, ac, "multiRow" ); TQT_BASE_OBJECT_NAME::connect( actions->wrapText, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( wrapText( bool ) ) ); actions->wrapText->setToolTip(i18n("Make the cell text wrap onto multiple lines.")); actions->verticalText = new KToggleAction( i18n("Vertical Text"),"vertical_text" , 0 ,ac, "verticaltext" ); TQT_BASE_OBJECT_NAME::connect( actions->verticalText, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( verticalText( bool ) ) ); actions->verticalText->setToolTip(i18n("Print cell contents vertically.")); actions->increaseIndent = new KAction( i18n("Increase Indent"), TQApplication::reverseLayout() ? "format_decreaseindent":"format_increaseindent", 0, TQT_TQOBJECT(view), TQT_SLOT( increaseIndent() ), ac, "increaseindent" ); actions->increaseIndent->setToolTip(i18n("Increase the indentation.")); actions->decreaseIndent = new KAction( i18n("Decrease Indent"), TQApplication::reverseLayout() ? "format_increaseindent" : "format_decreaseindent", 0, TQT_TQOBJECT(view), TQT_SLOT( decreaseIndent() ), ac, "decreaseindent"); actions->decreaseIndent->setToolTip(i18n("Decrease the indentation.")); actions->changeAngle = new KAction( i18n("Change Angle..."), 0, TQT_TQOBJECT(view), TQT_SLOT( changeAngle() ), ac, "changeangle" ); actions->changeAngle->setToolTip(i18n("Change the angle that cell contents are printed.")); actions->percent = new KToggleAction( i18n("Percent Format"), "percent", 0, ac, "percent"); TQT_BASE_OBJECT_NAME::connect( actions->percent, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( percent( bool ) ) ); actions->percent->setToolTip(i18n("Set the cell formatting to look like a percentage.")); actions->precplus = new KAction( i18n("Increase Precision"), "prec_plus", 0, TQT_TQOBJECT(view), TQT_SLOT( precisionPlus() ), ac, "precplus"); actions->precplus->setToolTip(i18n("Increase the decimal precision shown onscreen.")); actions->precminus = new KAction( i18n("Decrease Precision"), "prec_minus", 0, TQT_TQOBJECT(view), TQT_SLOT( precisionMinus() ), ac, "precminus"); actions->precminus->setToolTip(i18n("Decrease the decimal precision shown onscreen.")); actions->money = new KToggleAction( i18n("Money Format"), "money", 0, ac, "money"); TQT_BASE_OBJECT_NAME::connect( actions->money, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( moneyFormat( bool ) ) ); actions->money->setToolTip(i18n("Set the cell formatting to look like your local currency.")); actions->upper = new KAction( i18n("Upper Case"), "fontsizeup", 0, TQT_TQOBJECT(view), TQT_SLOT( upper() ), ac, "upper" ); actions->upper->setToolTip(i18n("Convert all letters to upper case.")); actions->lower = new KAction( i18n("Lower Case"), "fontsizedown", 0, TQT_TQOBJECT(view), TQT_SLOT( lower() ), ac, "lower" ); actions->lower->setToolTip(i18n("Convert all letters to lower case.")); actions->firstLetterUpper = new KAction( i18n("Convert First Letter to Upper Case"), "first_letter_upper", 0, TQT_TQOBJECT(view), TQT_SLOT( firstLetterUpper() ),ac, "firstletterupper" ); actions->firstLetterUpper->setToolTip(i18n("Capitalize the first letter.")); actions->bgColor = new TKSelectColorAction( i18n("Background Color"), TKSelectColorAction::FillColor, ac, "backgroundColor", true ); TQT_BASE_OBJECT_NAME::connect(actions->bgColor, TQT_SIGNAL( activated() ), TQT_TQOBJECT(view), TQT_SLOT( changeBackgroundColor() ) ); actions->bgColor->setDefaultColor(TQColor()); actions->bgColor->setToolTip(i18n("Set the background color.")); actions->borderLeft = new KAction( i18n("Border Left"), "border_left", 0, TQT_TQOBJECT(view), TQT_SLOT( borderLeft() ), ac, "borderLeft" ); actions->borderLeft->setToolTip(i18n("Set a left border to the selected area.")); actions->borderRight = new KAction( i18n("Border Right"), "border_right", 0, TQT_TQOBJECT(view), TQT_SLOT( borderRight() ), ac, "borderRight" ); actions->borderRight->setToolTip(i18n("Set a right border to the selected area.")); actions->borderTop = new KAction( i18n("Border Top"), "border_top", 0, TQT_TQOBJECT(view), TQT_SLOT( borderTop() ), ac, "borderTop" ); actions->borderTop->setToolTip(i18n("Set a top border to the selected area.")); actions->borderBottom = new KAction( i18n("Border Bottom"), "border_bottom", 0, TQT_TQOBJECT(view), TQT_SLOT( borderBottom() ), ac, "borderBottom" ); actions->borderBottom->setToolTip(i18n("Set a bottom border to the selected area.")); actions->borderAll = new KAction( i18n("All Borders"), "border_all", 0, TQT_TQOBJECT(view), TQT_SLOT( borderAll() ), ac, "borderAll" ); actions->borderAll->setToolTip(i18n("Set a border around all cells in the selected area.")); actions->borderRemove = new KAction( i18n("Remove Borders"), "border_remove", 0, TQT_TQOBJECT(view), TQT_SLOT( borderRemove() ), ac, "borderRemove" ); actions->borderRemove->setToolTip(i18n("Remove all borders in the selected area.")); actions->borderOutline = new KAction( i18n("Border Outline"), ("border_outline"), 0, TQT_TQOBJECT(view), TQT_SLOT( borderOutline() ), ac, "borderOutline" ); actions->borderOutline->setToolTip(i18n("Set a border to the outline of the selected area.")); actions->borderColor = new TKSelectColorAction( i18n("Border Color"), TKSelectColorAction::LineColor, ac, "borderColor" ); TQT_BASE_OBJECT_NAME::connect( actions->borderColor, TQT_SIGNAL( activated() ), TQT_TQOBJECT(view), TQT_SLOT( changeBorderColor() ) ); actions->borderColor->setToolTip( i18n( "Select a new border color." ) ); actions->selectStyle = new KSelectAction( i18n( "St&yle" ), 0, ac, "stylemenu" ); actions->selectStyle->setToolTip( i18n( "Apply a predefined style to the selected cells." ) ); TQT_BASE_OBJECT_NAME::connect( actions->selectStyle, TQT_SIGNAL( activated( const TQString & ) ), TQT_TQOBJECT(view), TQT_SLOT( styleSelected( const TQString & ) ) ); actions->createStyle = new KAction( i18n( "Create Style From Cell..." ), 0, TQT_TQOBJECT(view), TQT_SLOT( createStyleFromCell()), ac, "createStyle" ); actions->createStyle->setToolTip( i18n( "Create a new style based on the currently selected cell." ) ); // -- cell operation actions -- actions->editCell = new KAction( i18n("Modify Cell"),"cell_edit", TQt::CTRL+TQt::Key_M, TQT_TQOBJECT(view), TQT_SLOT( editCell() ), ac, "editCell" ); actions->editCell->setToolTip(i18n("Edit the highlighted cell.")); actions->insertCell = new KAction( i18n("Insert Cells..."), "insertcell", 0, TQT_TQOBJECT(view), TQT_SLOT( slotInsert() ), ac, "insertCell" ); actions->insertCell->setToolTip(i18n("Insert a blank cell into the spreadsheet.")); actions->removeCell = new KAction( i18n("Remove Cells..."), "removecell", 0, TQT_TQOBJECT(view), TQT_SLOT( slotRemove() ), ac, "removeCell" ); actions->removeCell->setToolTip(i18n("Removes the current cell from the spreadsheet.")); actions->deleteCell = new KAction( i18n("Delete"), "deletecell", 0, TQT_TQOBJECT(view), TQT_SLOT( deleteSelection() ), ac, "delete" ); actions->deleteCell->setToolTip(i18n("Delete all contents and formatting of the current cell.")); actions->mergeCell = new KToolBarPopupAction( i18n("Merge Cells"),"mergecell", 0, TQT_TQOBJECT(view), TQT_SLOT( mergeCell() ), ac, "mergecell" ); actions->mergeCell->setToolTip(i18n("Merge the selected region.")); actions->mergeCell->plug( actions->mergeCell->popupMenu() ); actions->mergeCellHorizontal = new KAction( i18n("Merge CellsQt::Horizontally"),"mergecell-horizontal", 0, TQT_TQOBJECT(view), TQT_SLOT( mergeCellHorizontal() ), ac, "mergecellHorizontal" ); actions->mergeCellHorizontal->setToolTip(i18n("Merge the selected region horizontally.")); actions->mergeCellHorizontal->plug( actions->mergeCell->popupMenu() ); actions->mergeCellVertical = new KAction( i18n("Merge CellsQt::Vertically"),"mergecell-vertical", 0, TQT_TQOBJECT(view), TQT_SLOT( mergeCellVertical() ), ac, "mergecellVertical" ); actions->mergeCellVertical->setToolTip(i18n("Merge the selected region vertically.")); actions->mergeCellVertical->plug( actions->mergeCell->popupMenu() ); actions->dissociateCell = new KAction( i18n("Dissociate Cells"),"dissociatecell", 0, TQT_TQOBJECT(view), TQT_SLOT( dissociateCell() ), ac, "dissociatecell" ); actions->dissociateCell->setToolTip(i18n("Unmerge the selected region.")); actions->clearText = new KAction( i18n("Text"), 0, TQT_TQOBJECT(view), TQT_SLOT( clearTextSelection() ), ac, "cleartext" ); actions->clearText->setToolTip(i18n("Remove the contents of the current cell.")); actions->conditional = new KAction( i18n("Conditional Cell Attributes..."), 0, TQT_TQOBJECT(view), TQT_SLOT( conditional() ), ac, "conditional" ); actions->conditional->setToolTip(i18n("Set cell format based on certain conditions.")); actions->clearConditional = new KAction( i18n("Conditional Cell Attributes"), 0, TQT_TQOBJECT(view), TQT_SLOT( clearConditionalSelection() ), ac, "clearconditional" ); actions->clearConditional->setToolTip(i18n("Remove the conditional cell formatting.")); actions->validity = new KAction( i18n("Validity..."), 0, TQT_TQOBJECT(view), TQT_SLOT( validity() ), ac, "validity" ); actions->validity->setToolTip(i18n("Set tests to confirm cell data is valid.")); actions->clearValidity = new KAction( i18n("Validity"), 0, TQT_TQOBJECT(view), TQT_SLOT( clearValiditySelection() ), ac, "clearvalidity" ); actions->clearValidity->setToolTip(i18n("Remove the validity tests on this cell.")); actions->addModifyComment = new KAction( i18n("&Add/Modify Comment..."),"comment", 0, TQT_TQOBJECT(view), TQT_SLOT( addModifyComment() ), ac, "addmodifycomment" ); actions->addModifyComment->setToolTip(i18n("Edit a comment for this cell.")); actions->removeComment = new KAction( i18n("&Remove Comment"),"removecomment", 0, TQT_TQOBJECT(view), TQT_SLOT( removeComment() ), ac, "removecomment" ); actions->removeComment->setToolTip(i18n("Remove this cell's comment.")); actions->clearComment = new KAction( i18n("Comment"), 0, TQT_TQOBJECT(view), TQT_SLOT( clearCommentSelection() ), ac, "clearcomment" ); actions->clearComment->setToolTip(i18n("Remove this cell's comment.")); // -- column & row actions -- actions->resizeColumn = new KAction( i18n("Resize Column..."), "resizecol", 0, TQT_TQOBJECT(view), TQT_SLOT( resizeColumn() ), ac, "resizeCol" ); actions->resizeColumn->setToolTip(i18n("Change the width of a column.")); actions->insertColumn = new KAction( i18n("Insert Columns"), "insert_table_col", 0, TQT_TQOBJECT(view), TQT_SLOT( insertColumn() ), ac, "insertColumn" ); actions->insertColumn->setToolTip(i18n("Inserts a new column into the spreadsheet.")); actions->deleteColumn = new KAction( i18n("Delete Columns"), "delete_table_col", 0, TQT_TQOBJECT(view), TQT_SLOT( deleteColumn() ), ac, "deleteColumn" ); actions->deleteColumn->setToolTip(i18n("Removes a column from the spreadsheet.")); actions->hideColumn = new KAction( i18n("Hide Columns"), "hide_table_column", 0, TQT_TQOBJECT(view), TQT_SLOT( hideColumn() ), ac, "hideColumn" ); actions->hideColumn->setToolTip(i18n("Hide the column from view.")); actions->showColumn = new KAction( i18n("Show Columns..."), "show_table_column", 0, TQT_TQOBJECT(view), TQT_SLOT( showColumn() ), ac, "showColumn" ); actions->showColumn->setToolTip(i18n("Show hidden columns.")); actions->equalizeColumn = new KAction( i18n("Equalize Column"), "adjustcol", 0, TQT_TQOBJECT(view), TQT_SLOT( equalizeColumn() ), ac, "equalizeCol" ); actions->equalizeColumn->setToolTip(i18n("Resizes selected columns to be the same size.")); actions->showSelColumns = new KAction( i18n("Show Columns"), "show_sheet_column", 0, TQT_TQOBJECT(view), TQT_SLOT( showSelColumns() ), ac, "showSelColumns" ); actions->showSelColumns->setToolTip(i18n("Show hidden columns in the selection.")); actions->showSelColumns->setEnabled(false); actions->resizeRow = new KAction( i18n("Resize Row..."), "resizerow", 0, TQT_TQOBJECT(view), TQT_SLOT( resizeRow() ), ac, "resizeRow" ); actions->resizeRow->setToolTip(i18n("Change the height of a row.")); actions->insertRow = new KAction( i18n("Insert Rows"), "insert_table_row", 0, TQT_TQOBJECT(view), TQT_SLOT( insertRow() ), ac, "insertRow" ); actions->insertRow->setToolTip(i18n("Inserts a new row into the spreadsheet.")); actions->deleteRow = new KAction( i18n("Delete Rows"), "delete_table_row", 0, TQT_TQOBJECT(view), TQT_SLOT( deleteRow() ), ac, "deleteRow" ); actions->deleteRow->setToolTip(i18n("Removes a row from the spreadsheet.")); actions->hideRow = new KAction( i18n("Hide Rows"), "hide_table_row", 0, TQT_TQOBJECT(view), TQT_SLOT( hideRow() ), ac, "hideRow" ); actions->hideRow->setToolTip(i18n("Hide a row from view.")); actions->showRow = new KAction( i18n("Show Rows..."), "show_table_row", 0, TQT_TQOBJECT(view), TQT_SLOT( showRow() ), ac, "showRow" ); actions->showRow->setToolTip(i18n("Show hidden rows.")); actions->equalizeRow = new KAction( i18n("Equalize Row"), "adjustrow", 0, TQT_TQOBJECT(view), TQT_SLOT( equalizeRow() ), ac, "equalizeRow" ); actions->equalizeRow->setToolTip(i18n("Resizes selected rows to be the same size.")); actions->showSelRows = new KAction( i18n("Show Rows"), "show_table_row", 0, TQT_TQOBJECT(view), TQT_SLOT( showSelRows() ), ac, "showSelRows" ); actions->showSelRows->setEnabled(false); actions->showSelRows->setToolTip(i18n("Show hidden rows in the selection.")); actions->adjust = new KAction( i18n("Adjust Row && Column"), 0, TQT_TQOBJECT(view), TQT_SLOT( adjust() ), ac, "adjust" ); actions->adjust->setToolTip(i18n("Adjusts row/column size so that the contents will fit.")); // -- sheet/workbook actions -- actions->sheetProperties = new KAction( i18n("Sheet Properties"), 0, TQT_TQOBJECT(view), TQT_SLOT( sheetProperties() ), ac, "sheetProperties" ); actions->sheetProperties->setToolTip(i18n("Modify current sheet's properties.")); actions->insertSheet = new KAction( i18n("Insert Sheet"),"inserttable", 0, TQT_TQOBJECT(view), TQT_SLOT( insertSheet() ), ac, "insertSheet" ); actions->insertSheet->setToolTip(i18n("Insert a new sheet.")); // same action as insertSheet, but without 'insert' in the caption actions->menuInsertSheet = new KAction( i18n("&Sheet"),"inserttable", 0, TQT_TQOBJECT(view), TQT_SLOT( insertSheet() ), ac, "menuInsertSheet" ); actions->menuInsertSheet->setToolTip(i18n("Insert a new sheet.")); actions->removeSheet = new KAction( i18n("Remove Sheet"), "delete_table", 0, TQT_TQOBJECT(view), TQT_SLOT( removeSheet() ), ac, "removeSheet" ); actions->removeSheet->setToolTip(i18n("Remove the active sheet.")); actions->renameSheet=new KAction( i18n("Rename Sheet..."), 0, TQT_TQOBJECT(view), TQT_SLOT( slotRename() ), ac, "renameSheet" ); actions->renameSheet->setToolTip(i18n("Rename the active sheet.")); actions->showSheet = new KAction(i18n("Show Sheet..."), 0, TQT_TQOBJECT(view), TQT_SLOT( showSheet()), ac, "showSheet" ); actions->showSheet->setToolTip(i18n("Show a hidden sheet.")); actions->hideSheet = new KAction(i18n("Hide Sheet"), 0, TQT_TQOBJECT(view), TQT_SLOT( hideSheet() ), ac, "hideSheet" ); actions->hideSheet->setToolTip(i18n("Hide the active sheet.")); actions->autoFormat = new KAction( i18n("AutoFormat..."), 0, TQT_TQOBJECT(view), TQT_SLOT( sheetFormat() ), ac, "sheetFormat" ); actions->autoFormat->setToolTip(i18n("Set the worksheet formatting.")); actions->areaName = new KAction( i18n("Area Name..."), 0, TQT_TQOBJECT(view), TQT_SLOT( setAreaName() ), ac, "areaname" ); actions->areaName->setToolTip(i18n("Set a name for a region of the spreadsheet.")); actions->showArea = new KAction( i18n("Show Area..."), 0, TQT_TQOBJECT(view), TQT_SLOT( showAreaName() ), ac, "showArea" ); actions->showArea->setToolTip(i18n("Display a named area.")); actions->insertFunction = new KAction( i18n("&Function..."), "funct", 0, TQT_TQOBJECT(view), TQT_SLOT( insertMathExpr() ), ac, "insertMathExpr" ); actions->insertFunction->setToolTip(i18n("Insert math expression.")); actions->insertSeries = new KAction( i18n("&Series..."),"series", 0, TQT_TQOBJECT(view), TQT_SLOT( insertSeries() ), ac, "series"); actions->insertSeries ->setToolTip(i18n("Insert a series.")); actions->insertLink = new KAction( i18n("&Link..."), "insert_link", 0, TQT_TQOBJECT(view), TQT_SLOT( insertHyperlink() ), ac, "insertHyperlink" ); actions->insertLink->setToolTip(i18n("Insert an Internet hyperlink.")); actions->removeLink = new KAction( i18n("&Remove Link"), 0, TQT_TQOBJECT(view), TQT_SLOT( removeHyperlink() ), ac, "removeHyperlink" ); actions->removeLink->setToolTip(i18n("Remove a link.")); actions->insertSpecialChar = new KAction( i18n( "S&pecial Character..." ), "char", TQT_TQOBJECT(view), TQT_SLOT( insertSpecialChar() ), ac, "insertSpecialChar" ); actions->insertSpecialChar->setToolTip( i18n( "Insert one or more symbols or letters not found on the keyboard." ) ); actions->insertPart = new KoPartSelectAction( i18n("&Object"), "frame_query", TQT_TQOBJECT(view), TQT_SLOT( insertObject() ), ac, "insertPart"); actions->insertPart->setToolTip(i18n("Insert an object from another program.")); actions->insertChartFrame = new KToggleAction( i18n("&Chart"), "insert_chart", 0, TQT_TQOBJECT(view), TQT_SLOT( insertChart() ), ac, "insertChart" ); actions->insertChartFrame->setToolTip(i18n("Insert a chart.")); actions->insertPicture = new KAction( i18n("&Picture"), 0, TQT_TQOBJECT(view), TQT_SLOT( insertPicture() ), ac, "insertPicture" ); actions->insertPicture->setToolTip(i18n("Insert a picture.")); #ifndef TQT_NO_SQL actions->insertFromDatabase = new KAction( i18n("From &Database..."), 0, TQT_TQOBJECT(view), TQT_SLOT( insertFromDatabase() ), ac, "insertFromDatabase"); actions->insertFromDatabase->setToolTip(i18n("Insert data from a SQL database.")); #endif actions->insertFromTextfile = new KAction( i18n("From &Text File..."), 0, TQT_TQOBJECT(view), TQT_SLOT( insertFromTextfile() ), ac, "insertFromTextfile"); actions->insertFromTextfile->setToolTip(i18n("Insert data from a text file to the current cursor position/selection.")); actions->insertFromClipboard = new KAction( i18n("From &Clipboard..."), 0, TQT_TQOBJECT(view), TQT_SLOT( insertFromClipboard() ), ac, "insertFromClipboard"); actions->insertFromClipboard->setToolTip(i18n("Insert CSV data from the clipboard to the current cursor position/selection.")); // actions->transform = new KAction( i18n("Transform Object..."), "rotate", // 0, TQT_TQOBJECT(view), TQT_SLOT( transformPart() ), ac, "transform" ); // actions->transform->setToolTip(i18n("Rotate the contents of the cell.")); // actions->transform->setEnabled( false ); actions->sort = new KAction( i18n("&Sort..."), 0, TQT_TQOBJECT(view), TQT_SLOT( sort() ), ac, "sort" ); actions->sort->setToolTip(i18n("Sort a group of cells.")); actions->sortDec = new KAction( i18n("Sort &Decreasing"), "sort_decrease", 0, TQT_TQOBJECT(view), TQT_SLOT( sortDec() ), ac, "sortDec" ); actions->sortDec->setToolTip(i18n("Sort a group of cells in decreasing (last to first) order.")); actions->sortInc = new KAction( i18n("Sort &Increasing"), "sort_incr", 0, TQT_TQOBJECT(view), TQT_SLOT( sortInc() ), ac, "sortInc" ); actions->sortInc->setToolTip(i18n("Sort a group of cells in ascending (first to last) order.")); actions->paperLayout = new KAction( i18n("Page Layout..."), 0, TQT_TQOBJECT(view), TQT_SLOT( paperLayoutDlg() ), ac, "paperLayout" ); actions->paperLayout->setToolTip(i18n("Specify the layout of the spreadsheet for a printout.")); actions->definePrintRange = new KAction( i18n("Define Print Range"), 0, TQT_TQOBJECT(view), TQT_SLOT( definePrintRange() ), ac, "definePrintRange" ); actions->definePrintRange->setToolTip(i18n("Define the print range in the current sheet.")); actions->resetPrintRange = new KAction( i18n("Reset Print Range"), 0, TQT_TQOBJECT(view), TQT_SLOT( resetPrintRange() ), ac, "resetPrintRange" ); actions->definePrintRange->setToolTip(i18n("Define the print range in the current sheet.")); actions->showPageBorders = new KToggleAction( i18n("Show Page Borders"), 0, ac, "showPageBorders"); actions->showPageBorders->setCheckedState(i18n("Hide Page Borders")); TQT_BASE_OBJECT_NAME::connect( actions->showPageBorders, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( togglePageBorders( bool ) ) ); actions->showPageBorders->setToolTip( i18n( "Show on the spreadsheet where the page borders will be." ) ); actions->recalcWorksheet = new KAction( i18n("Recalculate Sheet"), TQt::SHIFT + TQt::Key_F9, TQT_TQOBJECT(view), TQT_SLOT( recalcWorkSheet() ), ac, "RecalcWorkSheet" ); actions->recalcWorksheet->setToolTip(i18n("Recalculate the value of every cell in the current worksheet.")); actions->recalcWorkbook = new KAction( i18n("Recalculate Document"), TQt::Key_F9, TQT_TQOBJECT(view), TQT_SLOT( recalcWorkBook() ), ac, "RecalcWorkBook" ); actions->recalcWorkbook->setToolTip(i18n("Recalculate the value of every cell in all worksheets.")); actions->protectSheet = new KToggleAction( i18n( "Protect &Sheet..." ), 0, ac, "protectSheet" ); actions->protectSheet->setToolTip( i18n( "Protect the sheet from being modified." ) ); TQT_BASE_OBJECT_NAME::connect( actions->protectSheet, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( toggleProtectSheet( bool ) ) ); actions->protectDoc = new KToggleAction( i18n( "Protect &Document..." ), 0, ac, "protectDoc" ); actions->protectDoc->setToolTip( i18n( "Protect the document from being modified." ) ); TQT_BASE_OBJECT_NAME::connect( actions->protectDoc, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( toggleProtectDoc( bool ) ) ); // -- editing actions -- actions->copy = KStdAction::copy( TQT_TQOBJECT(view), TQT_SLOT( copySelection() ), ac, "copy" ); actions->copy->setToolTip(i18n("Copy the cell object to the clipboard.")); actions->paste = KStdAction::paste( TQT_TQOBJECT(view), TQT_SLOT( paste() ), ac, "paste" ); actions->paste->setToolTip(i18n("Paste the contents of the clipboard at the cursor.")); actions->cut = KStdAction::cut( TQT_TQOBJECT(view), TQT_SLOT( cutSelection() ), ac, "cut" ); actions->cut->setToolTip(i18n("Move the cell object to the clipboard.")); actions->specialPaste = new KAction( i18n("Special Paste..."), "special_paste", 0, TQT_TQOBJECT(view), TQT_SLOT( specialPaste() ), ac, "specialPaste" ); actions->specialPaste->setToolTip(i18n("Paste the contents of the clipboard with special options.")); actions->insertCellCopy = new KAction( i18n("Paste with Insertion"), "insertcellcopy", 0, TQT_TQOBJECT(view), TQT_SLOT( slotInsertCellCopy() ), ac, "insertCellCopy" ); actions->insertCellCopy->setToolTip(i18n("Inserts a cell from the clipboard into the spreadsheet.")); actions->find = KStdAction::find( TQT_TQOBJECT(view), TQT_SLOT(find()), ac ); /*actions->findNext =*/ KStdAction::findNext( TQT_TQOBJECT(view), TQT_SLOT( findNext() ), ac ); /*actions->findPrevious =*/ KStdAction::findPrev( TQT_TQOBJECT(view), TQT_SLOT( findPrevious() ), ac ); actions->replace = KStdAction::replace( TQT_TQOBJECT(view), TQT_SLOT(replace()), ac ); actions->fillRight = new KAction( i18n( "&Right" ), 0, 0, TQT_TQOBJECT(view), TQT_SLOT( fillRight() ), ac, "fillRight" ); actions->fillLeft = new KAction( i18n( "&Left" ), 0, 0, TQT_TQOBJECT(view), TQT_SLOT( fillLeft() ), ac, "fillLeft" ); actions->fillDown = new KAction( i18n( "&Down" ), 0, 0, TQT_TQOBJECT(view), TQT_SLOT( fillDown() ), ac, "fillDown" ); actions->fillUp = new KAction( i18n( "&Up" ), 0, 0, TQT_TQOBJECT(view), TQT_SLOT( fillUp() ), ac, "fillUp" ); // -- misc actions -- actions->styleDialog = new KAction( i18n( "Style Manager" ), 0, TQT_TQOBJECT(view), TQT_SLOT( styleDialog() ), ac, "styles" ); actions->styleDialog->setToolTip( i18n( "Edit and organize cell styles." ) ); actions->autoSum = new KAction( i18n("Autosum"), "black_sum", 0, TQT_TQOBJECT(view), TQT_SLOT( autoSum() ), ac, "autoSum" ); actions->autoSum->setToolTip(i18n("Insert the 'sum' function")); actions->spellChecking = KStdAction::spelling( TQT_TQOBJECT(view), TQT_SLOT( extraSpelling() ), ac, "spelling" ); actions->spellChecking->setToolTip(i18n("Check the spelling.")); actions->formulaSelection = new KSelectAction(i18n("Formula Selection"), 0, ac, "formulaSelection"); actions->formulaSelection->setToolTip(i18n("Insert a function.")); TQStringList lst; lst.append( "SUM"); lst.append( "AVERAGE"); lst.append( "IF"); lst.append( "COUNT"); lst.append( "MIN"); lst.append( "MAX"); lst.append( i18n("Others...") ); ((KSelectAction*) actions->formulaSelection)->setItems( lst ); actions->formulaSelection->setComboWidth( 80 ); actions->formulaSelection->setCurrentItem(0); TQT_BASE_OBJECT_NAME::connect( actions->formulaSelection, TQT_SIGNAL( activated( const TQString& ) ), TQT_TQOBJECT(view), TQT_SLOT( formulaSelection( const TQString& ) ) ); actions->viewZoom = new KoZoomAction( i18n( "Zoom" ), "viewmag", 0, ac, "view_zoom" ); TQT_BASE_OBJECT_NAME::connect( actions->viewZoom, TQT_SIGNAL( zoomChanged( const TQString & ) ), TQT_TQOBJECT(view), TQT_SLOT( viewZoom( const TQString & ) ) ); actions->consolidate = new KAction( i18n("&Consolidate..."), 0, TQT_TQOBJECT(view), TQT_SLOT( consolidate() ), ac, "consolidate" ); actions->consolidate->setToolTip(i18n("Create a region of summary data from a group of similar regions.")); actions->goalSeek = new KAction( i18n("&Goal Seek..."), 0, TQT_TQOBJECT(view), TQT_SLOT( goalSeek() ), ac, "goalSeek" ); actions->goalSeek->setToolTip( i18n("Repeating calculation to find a specific value.") ); actions->subTotals = new KAction( i18n("&Subtotals..."), 0, TQT_TQOBJECT(view), TQT_SLOT( subtotals() ), ac, "subtotals" ); actions->subTotals->setToolTip( i18n("Create different kind of subtotals to a list or database.") ); actions->textToColumns = new KAction( i18n("&Text to Columns..."), 0, TQT_TQOBJECT(view), TQT_SLOT( textToColumns() ), ac, "textToColumns" ); actions->textToColumns->setToolTip( i18n("Expand the content of cells to multiple columns.") ); actions->multipleOperations = new KAction( i18n("&Multiple Operations..."), 0, TQT_TQOBJECT(view), TQT_SLOT( multipleOperations() ), ac, "multipleOperations" ); actions->multipleOperations->setToolTip( i18n("Apply the same formula to various cells using different values for the parameter.") ); actions->createTemplate = new KAction( i18n( "&Create Template From Document..." ), 0, TQT_TQOBJECT(view), TQT_SLOT( createTemplate() ), ac, "createTemplate" ); actions->customList = new KAction( i18n("Custom Lists..."), 0, TQT_TQOBJECT(view), TQT_SLOT( sortList() ), ac, "sortlist" ); actions->customList->setToolTip(i18n("Create custom lists for sorting or autofill.")); // -- navigation actions -- actions->gotoCell = new KAction( i18n("Goto Cell..."),"goto", 0, TQT_TQOBJECT(view), TQT_SLOT( gotoCell() ), ac, "gotoCell" ); actions->gotoCell->setToolTip(i18n("Move to a particular cell.")); actions->nextSheet = new KAction( i18n("Next Sheet"), "forward", TQt::CTRL+TQt::Key_PageDown, TQT_TQOBJECT(view), TQT_SLOT( nextSheet() ), ac, "nextSheet"); actions->nextSheet->setToolTip(i18n("Move to the next sheet.")); actions->prevSheet = new KAction( i18n("Previous Sheet"), "back", TQt::CTRL+TQt::Key_PageUp, TQT_TQOBJECT(view), TQT_SLOT( previousSheet() ), ac, "previousSheet"); actions->prevSheet->setToolTip(i18n("Move to the previous sheet.")); actions->firstSheet = new KAction( i18n("First Sheet"), "start", 0, TQT_TQOBJECT(view), TQT_SLOT( firstSheet() ), ac, "firstSheet"); actions->firstSheet->setToolTip(i18n("Move to the first sheet.")); actions->lastSheet = new KAction( i18n("Last Sheet"), "finish", 0, TQT_TQOBJECT(view), TQT_SLOT( lastSheet() ), ac, "lastSheet"); actions->lastSheet->setToolTip(i18n("Move to the last sheet.")); // -- settings actions -- actions->showStatusBar = new KToggleAction( i18n("Show Status Bar"), 0, ac, "showStatusBar" ); actions->showStatusBar->setCheckedState(i18n("Hide Status Bar")); TQT_BASE_OBJECT_NAME::connect( actions->showStatusBar, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( showStatusBar( bool ) ) ); actions->showStatusBar->setToolTip(i18n("Show the status bar.")); actions->showTabBar = new KToggleAction( i18n("Show Tab Bar"), 0, ac, "showTabBar" ); actions->showTabBar->setCheckedState(i18n("Hide Tab Bar")); TQT_BASE_OBJECT_NAME::connect( actions->showTabBar, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( showTabBar( bool ) ) ); actions->showTabBar->setToolTip(i18n("Show the tab bar.")); actions->showFormulaBar = new KToggleAction( i18n("Show Formula Bar"), 0, ac, "showFormulaBar" ); actions->showFormulaBar->setCheckedState(i18n("Hide Formula Bar")); TQT_BASE_OBJECT_NAME::connect( actions->showFormulaBar, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( showFormulaBar( bool ) ) ); actions->showFormulaBar->setToolTip(i18n("Show the formula bar.")); actions->preference = new KAction( i18n("Configure KSpread..."),"configure", 0, TQT_TQOBJECT(view), TQT_SLOT( preference() ), ac, "preference" ); actions->preference->setToolTip(i18n("Set various KSpread options.")); // -- running calculation actions -- actions->calcNone = new KToggleAction( i18n("None"), 0, ac, "menu_none"); TQT_BASE_OBJECT_NAME::connect( actions->calcNone, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcNone->setExclusiveGroup( "Calc" ); actions->calcNone->setToolTip(i18n("No calculation")); actions->calcSum = new KToggleAction( i18n("Sum"), 0, ac, "menu_sum"); TQT_BASE_OBJECT_NAME::connect( actions->calcSum, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcSum->setExclusiveGroup( "Calc" ); actions->calcSum->setToolTip(i18n("Calculate using sum.")); actions->calcMin = new KToggleAction( i18n("Min"), 0, ac, "menu_min"); TQT_BASE_OBJECT_NAME::connect( actions->calcMin, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcMin->setExclusiveGroup( "Calc" ); actions->calcMin->setToolTip(i18n("Calculate using minimum.")); actions->calcMax = new KToggleAction( i18n("Max"), 0, ac, "menu_max"); TQT_BASE_OBJECT_NAME::connect( actions->calcMax, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcMax->setExclusiveGroup( "Calc" ); actions->calcMax->setToolTip(i18n("Calculate using maximum.")); actions->calcAverage = new KToggleAction( i18n("Average"), 0, ac, "menu_average"); TQT_BASE_OBJECT_NAME::connect( actions->calcAverage, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcAverage->setExclusiveGroup( "Calc" ); actions->calcAverage->setToolTip(i18n("Calculate using average.")); actions->calcCount = new KToggleAction( i18n("Count"), 0, ac, "menu_count"); TQT_BASE_OBJECT_NAME::connect( actions->calcCount, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcCount->setExclusiveGroup( "Calc" ); actions->calcCount->setToolTip(i18n("Calculate using the count.")); actions->calcCountA = new KToggleAction( i18n("CountA"), 0, ac, "menu_counta"); TQT_BASE_OBJECT_NAME::connect( actions->calcCountA, TQT_SIGNAL( toggled( bool ) ), TQT_TQOBJECT(view), TQT_SLOT( menuCalc( bool ) ) ); actions->calcCountA->setExclusiveGroup( "Calc" ); actions->calcCountA->setToolTip(i18n("Calculate using the countA.")); // -- special action, only for developers -- actions->internalTests = new KAction( i18n("Run Internal Tests..."), "internalTests", TQt::CTRL+ TQt::SHIFT + TQt::Key_T, TQT_TQOBJECT(view), TQT_SLOT( runInternalTests() ), ac, "internalTests" ); actions->inspector = new KAction( i18n("Run Inspector..."), "inspector", TQt::CTRL+ TQt::SHIFT + TQt::Key_I, TQT_TQOBJECT(view), TQT_SLOT( runInspector() ), ac, "inspector" ); m_propertyEditor = 0; } void View::Private::adjustActions( bool mode ) { actions->replace->setEnabled( mode ); actions->insertSeries->setEnabled( mode ); actions->insertLink->setEnabled( mode ); actions->insertSpecialChar->setEnabled( mode ); actions->insertFunction->setEnabled( mode ); actions->removeComment->setEnabled( mode ); actions->decreaseIndent->setEnabled( mode ); actions->bold->setEnabled( mode ); actions->italic->setEnabled( mode ); actions->underline->setEnabled( mode ); actions->strikeOut->setEnabled( mode ); actions->percent->setEnabled( mode ); actions->precplus->setEnabled( mode ); actions->precminus->setEnabled( mode ); actions->money->setEnabled( mode ); actions->alignLeft->setEnabled( mode ); actions->alignCenter->setEnabled( mode ); actions->alignRight->setEnabled( mode ); actions->alignTop->setEnabled( mode ); actions->alignMiddle->setEnabled( mode ); actions->alignBottom->setEnabled( mode ); actions->paste->setEnabled( mode ); actions->cut->setEnabled( mode ); actions->specialPaste->setEnabled( mode ); actions->deleteCell->setEnabled( mode ); actions->clearText->setEnabled( mode ); actions->clearComment->setEnabled( mode ); actions->clearValidity->setEnabled( mode ); actions->clearConditional->setEnabled( mode ); actions->recalcWorkbook->setEnabled( mode ); actions->recalcWorksheet->setEnabled( mode ); actions->adjust->setEnabled( mode ); actions->editCell->setEnabled( mode ); actions->paperLayout->setEnabled( mode ); actions->styleDialog->setEnabled( mode ); actions->definePrintRange->setEnabled( mode ); actions->resetPrintRange->setEnabled( mode ); actions->insertFromDatabase->setEnabled( mode ); actions->insertFromTextfile->setEnabled( mode ); actions->insertFromClipboard->setEnabled( mode ); actions->conditional->setEnabled( mode ); actions->validity->setEnabled( mode ); actions->goalSeek->setEnabled( mode ); actions->subTotals->setEnabled( mode ); actions->multipleOperations->setEnabled( mode ); actions->textToColumns->setEnabled( mode ); actions->consolidate->setEnabled( mode ); actions->insertCellCopy->setEnabled( mode ); actions->wrapText->setEnabled( mode ); actions->selectFont->setEnabled( mode ); actions->selectFontSize->setEnabled( mode ); actions->deleteColumn->setEnabled( mode ); actions->hideColumn->setEnabled( mode ); actions->showColumn->setEnabled( mode ); actions->showSelColumns->setEnabled( mode ); actions->insertColumn->setEnabled( mode ); actions->deleteRow->setEnabled( mode ); actions->insertRow->setEnabled( mode ); actions->hideRow->setEnabled( mode ); actions->showRow->setEnabled( mode ); actions->showSelRows->setEnabled( mode ); actions->formulaSelection->setEnabled( mode ); actions->textColor->setEnabled( mode ); actions->bgColor->setEnabled( mode ); actions->cellLayout->setEnabled( mode ); actions->borderLeft->setEnabled( mode ); actions->borderRight->setEnabled( mode ); actions->borderTop->setEnabled( mode ); actions->borderBottom->setEnabled( mode ); actions->borderAll->setEnabled( mode ); actions->borderOutline->setEnabled( mode ); actions->borderRemove->setEnabled( mode ); actions->borderColor->setEnabled( mode ); actions->removeSheet->setEnabled( mode ); actions->autoSum->setEnabled( mode ); actions->defaultFormat->setEnabled( mode ); actions->areaName->setEnabled( mode ); actions->resizeRow->setEnabled( mode ); actions->resizeColumn->setEnabled( mode ); actions->fontSizeUp->setEnabled( mode ); actions->fontSizeDown->setEnabled( mode ); actions->upper->setEnabled( mode ); actions->lower->setEnabled( mode ); actions->equalizeRow->setEnabled( mode ); actions->equalizeColumn->setEnabled( mode ); actions->verticalText->setEnabled( mode ); actions->addModifyComment->setEnabled( mode ); actions->removeComment->setEnabled( mode ); actions->insertCell->setEnabled( mode ); actions->removeCell->setEnabled( mode ); actions->changeAngle->setEnabled( mode ); actions->dissociateCell->setEnabled( mode ); actions->increaseIndent->setEnabled( mode ); actions->decreaseIndent->setEnabled( mode ); actions->spellChecking->setEnabled( mode ); actions->calcMin->setEnabled( mode ); actions->calcMax->setEnabled( mode ); actions->calcAverage->setEnabled( mode ); actions->calcCount->setEnabled( mode ); actions->calcCountA->setEnabled( mode ); actions->calcSum->setEnabled( mode ); actions->calcNone->setEnabled( mode ); actions->insertPart->setEnabled( mode ); actions->createStyle->setEnabled( mode ); actions->selectStyle->setEnabled( mode ); actions->insertChartFrame->setEnabled( mode ); actions->autoFormat->setEnabled( false ); actions->sort->setEnabled( false ); actions->mergeCell->setEnabled( false ); actions->mergeCellHorizontal->setEnabled( false ); actions->mergeCellVertical->setEnabled( false ); actions->sortDec->setEnabled( false ); actions->sortInc->setEnabled( false ); // actions->transform->setEnabled( false ); actions->fillRight->setEnabled( false ); actions->fillLeft->setEnabled( false ); actions->fillUp->setEnabled( false ); actions->fillDown->setEnabled( false ); if ( mode && !view->doc()->map()->isProtected() ) actions->renameSheet->setEnabled( true ); else actions->renameSheet->setEnabled( false ); actions->showStatusBar->setChecked( view->doc()->showStatusBar() ); actions->showTabBar->setChecked( view->doc()->showTabBar() ); actions->showFormulaBar->setChecked( view->doc()->showFormulaBar() ); formulaButton->setEnabled( mode ); if ( activeSheet ) { selection->update(); view->objectSelectedChanged(); } } void View::Private::adjustActions( Sheet* sheet, Cell* cell ) { if ( sheet->isProtected() && !cell->isDefault() && cell->format()->notProtected( cell->column(), cell->row() ) ) { if ( selection->isSingular() ) { if ( !actions->bold->isEnabled() ) adjustActions( true ); } else { if ( actions->bold->isEnabled() ) adjustActions( false ); } } else if ( sheet->isProtected() ) { if ( actions->bold->isEnabled() ) adjustActions( false ); } } void View::Private::adjustWorkbookActions( bool mode ) { tabBar->setReadOnly( !view->doc()->isReadWrite() || view->doc()->map()->isProtected() ); actions->hideSheet->setEnabled( mode ); actions->showSheet->setEnabled( mode ); actions->insertSheet->setEnabled( mode ); actions->menuInsertSheet->setEnabled( mode ); actions->removeSheet->setEnabled( mode ); if ( mode ) { if ( activeSheet && !activeSheet->isProtected() ) { bool state = ( view->doc()->map()->visibleSheets().count() > 1 ); actions->removeSheet->setEnabled( state ); actions->hideSheet->setEnabled( state ); } actions->showSheet->setEnabled( view->doc()->map()->hiddenSheets().count() > 0 ); actions->renameSheet->setEnabled( activeSheet && !activeSheet->isProtected() ); } } // TODO this should be merged with adjustActions void View::Private::updateButton( Cell *cell, int column, int row) { toolbarLock = true; // workaround for bug #59291 (crash upon starting from template) // certain TQt and Fontconfig combination fail miserably if can not // find the font name (e.g. not installed in the system) TQStringList fontList; KFontChooser::getFontList( fontList, 0 ); TQString fontFamily = cell->format()->textFontFamily( column,row ); for ( TQStringList::Iterator it = fontList.begin(); it != fontList.end(); ++it ) if ((*it).lower() == fontFamily.lower()) { actions->selectFont->setFont( fontFamily ); break; } actions->selectFontSize->setFontSize( cell->format()->textFontSize( column, row ) ); actions->bold->setChecked( cell->format()->textFontBold( column, row ) ); actions->italic->setChecked( cell->format()->textFontItalic( column, row) ); actions->underline->setChecked( cell->format()->textFontUnderline( column, row ) ); actions->strikeOut->setChecked( cell->format()->textFontStrike( column, row ) ); actions->alignLeft->setChecked( cell->format()->align( column, row ) == Format::Left ); actions->alignCenter->setChecked( cell->format()->align( column, row ) == Format::Center ); actions->alignRight->setChecked( cell->format()->align( column, row ) == Format::Right ); actions->alignTop->setChecked( cell->format()->alignY( column, row ) == Format::Top ); actions->alignMiddle->setChecked( cell->format()->alignY( column, row ) == Format::Middle ); actions->alignBottom->setChecked( cell->format()->alignY( column, row ) == Format::Bottom ); actions->verticalText->setChecked( cell->format()->verticalText( column,row ) ); actions->wrapText->setChecked( cell->format()->multiRow( column,row ) ); FormatType ft = cell->formatType(); actions->percent->setChecked( ft == Percentage_format ); actions->money->setChecked( ft == Money_format ); if ( activeSheet && !activeSheet->isProtected() ) actions->removeComment->setEnabled( !cell->format()->comment(column,row).isEmpty() ); if ( activeSheet && !activeSheet->isProtected() ) actions->decreaseIndent->setEnabled( cell->format()->getIndent( column, row ) > 0.0 ); toolbarLock = false; if ( activeSheet ) adjustActions( activeSheet, cell ); } TQButton* View::Private::newIconButton( const char *_file, bool _kbutton, TQWidget *_parent ) { if ( _parent == 0L ) _parent = view; if ( !_kbutton ) { TQPushButton* pb = new TQPushButton( _parent ); pb->setIconSet( SmallIconSet(_file) ); return pb; } else { TQToolButton* pb = new TQToolButton( _parent ); pb->setIconSet( SmallIconSet(_file) ); return pb; } } KPSheetSelectPage::KPSheetSelectPage( TQWidget *parent ) : KPrintDialogPage(parent), gui(new SheetSelectWidget(this)) { setTitle(gui->caption()); //disabling automated sorting gui->ListViewAvailable->setSorting(-1); gui->ListViewSelected->setSorting(-1); //connect buttons connect(gui->ButtonSelectAll,TQT_SIGNAL(clicked()),this,TQT_SLOT(selectAll())); connect(gui->ButtonSelect,TQT_SIGNAL(clicked()),this,TQT_SLOT(select())); connect(gui->ButtonRemove,TQT_SIGNAL(clicked()),this,TQT_SLOT(remove())); connect(gui->ButtonRemoveAll,TQT_SIGNAL(clicked()),this,TQT_SLOT(removeAll())); connect(gui->ButtonMoveTop,TQT_SIGNAL(clicked()),this,TQT_SLOT(moveTop())); connect(gui->ButtonMoveUp,TQT_SIGNAL(clicked()),this,TQT_SLOT(moveUp())); connect(gui->ButtonMoveDown,TQT_SIGNAL(clicked()),this,TQT_SLOT(moveDown())); connect(gui->ButtonMoveBottom,TQT_SIGNAL(clicked()),this,TQT_SLOT(moveBottom())); } // KPSheetSelectPage::~KPSheetSelectPage() // { // } void KPSheetSelectPage::getOptions( TQMap<TQString,TQString>& opts, bool /*incldef*/ ) { TQStringList sheetlist = this->selectedSheets(); TQStringList::iterator it; unsigned int i = 0; for (it = sheetlist.begin(); it != sheetlist.end(); ++it, i++) { opts.insert(printOptionForIndex(i),*it); } } void KPSheetSelectPage::setOptions( const TQMap<TQString,TQString>& opts ) { unsigned int i = 0; TQStringList sheetlist; while (opts.contains(printOptionForIndex(i))) { sheetlist.prepend(opts[printOptionForIndex(i++)]); } TQStringList::iterator it; for (it = sheetlist.begin(); it != sheetlist.end(); ++it) { kdDebug() << " adding sheet to list of printed sheets: " << *it << endl; this->prependSelectedSheet(*it); } } bool KPSheetSelectPage::isValid(TQString& /*msg*/) { // we print the activeSheet() by default if no sheet is selected, // so we return true in any case // Q_ASSERT(gui); // if (gui->ListViewSelected->childCount() < 1) // { // msg = i18n("No sheets selected for printing!"); // return false; // } return true; } TQString KPSheetSelectPage::printOptionForIndex(unsigned int index) { return TQString("sheetprintorder%1").arg(index); } void KPSheetSelectPage::prependAvailableSheet(const TQString& sheetname) { Q_ASSERT(gui); new TQListViewItem(gui->ListViewAvailable,sheetname); } void KPSheetSelectPage::prependSelectedSheet(const TQString& sheetname) { Q_ASSERT(gui); new TQListViewItem(gui->ListViewSelected,sheetname); } TQStringList KPSheetSelectPage::selectedSheets() { Q_ASSERT(gui); TQStringList list; TQListViewItem* item = gui->ListViewSelected->firstChild(); while (item) { list.append(item->text(0)); item = item->nextSibling(); } return list; } TQStringList KPSheetSelectPage::selectedSheets(KPrinter &prt) { TQStringList list; unsigned int index; const TQMap<TQString,TQString>& options = prt.options(); for (index = 0; options.contains(KPSheetSelectPage::printOptionForIndex(index)); index++) { list.append(options[KPSheetSelectPage::printOptionForIndex(index)]); } return list; } void KPSheetSelectPage::clearSelection() { gui->ListViewSelected->clear(); } void KPSheetSelectPage::selectAll() { //we have to add all the stuff in reverse order // because inserted items (prependSelectedSheet) are prepended TQStringList list; TQListViewItem* item = gui->ListViewAvailable->firstChild(); while (item) { list.prepend(item->text(0)); item = item->nextSibling(); } TQStringList::iterator it; for (it = list.begin(); it != list.end(); ++it) { this->prependSelectedSheet(*it); } } void KPSheetSelectPage::select() { //we have to add all the stuff in reverse order // because inserted items (prependSelectedSheet) are prepended TQStringList list; TQListViewItem* item = gui->ListViewAvailable->firstChild(); while (item) { if (item->isSelected()) list.prepend(item->text(0)); item = item->nextSibling(); } TQStringList::iterator it; for (it = list.begin(); it != list.end(); ++it) { this->prependSelectedSheet(*it); } } void KPSheetSelectPage::remove() { TQListViewItem* item = gui->ListViewSelected->firstChild(); TQListViewItem* nextitem = NULL; while (item) { nextitem = item->nextSibling(); if (item->isSelected()) delete item; item = nextitem; } } void KPSheetSelectPage::removeAll() { gui->ListViewSelected->clear(); } void KPSheetSelectPage::moveTop() { //this creates a temporary new list (selected first, then rest) // which replaces the existing one, to avoid the need of an additional sort column TQValueList<TQListViewItem*> newlist; TQListViewItem* item = gui->ListViewSelected->firstChild(); TQListViewItem* nextitem = NULL; // kdDebug() << "Filling new list with selected items first" << endl; while (item) { nextitem = item->nextSibling(); if (item->isSelected()) { newlist.prepend(item); gui->ListViewSelected->takeItem(item); } item = nextitem; } // kdDebug() << "Appending the rest" << endl; item = gui->ListViewSelected->firstChild(); while (item) { // kdDebug() << " processing item " << item->text(0) << endl; nextitem = item->nextSibling(); if (!item->isSelected()) { newlist.prepend(item); gui->ListViewSelected->takeItem(item); } item = nextitem; } // kdDebug() << "Refill the view with the correctly ordered list" << endl; //the view is empty now, refill in correct order (reversed!!) TQValueList<TQListViewItem*>::iterator it; for (it = newlist.begin(); it != newlist.end(); ++it) { // kdDebug() << " adding " << (*it)->text(0) << endl; gui->ListViewSelected->insertItem(*it); } } void KPSheetSelectPage::moveUp() { //this creates a temporary new list // which replaces the existing one, to avoid the need of an additional sort column TQValueList<TQListViewItem*> newlist; TQListViewItem* item = gui->ListViewSelected->firstChild(); TQListViewItem* nextitem = NULL; while (item) { nextitem = item->nextSibling(); if (!item->isSelected()) { while (nextitem && nextitem->isSelected()) { TQListViewItem* nextnextitem = nextitem->nextSibling(); newlist.prepend(nextitem); gui->ListViewSelected->takeItem(nextitem); nextitem = nextnextitem; } } newlist.prepend(item); gui->ListViewSelected->takeItem(item); item = nextitem; } // kdDebug() << "Refill the view with the correctly ordered list" << endl; //the view is empty now, refill in correct order (reversed!!) TQValueList<TQListViewItem*>::iterator it; for (it = newlist.begin(); it != newlist.end(); ++it) { // kdDebug() << " adding " << (*it)->text(0) << endl; gui->ListViewSelected->insertItem(*it); } } void KPSheetSelectPage::moveDown() { TQListViewItem* item = gui->ListViewSelected->lastItem(); // while (item) // { // nextitem = item->nextSibling(); // if (previousitem && previousitem->isSelected()) // { // previousitem->moveItem(item); // } // previousitem = item; // item = nextitem; // } while (item) { while (item && !item->isSelected() && item->itemAbove() && item->itemAbove()->isSelected()) { TQListViewItem* tempitem = item->itemAbove(); tempitem->moveItem(item); } if (item) item = item->itemAbove(); } } void KPSheetSelectPage::moveBottom() { //this creates a temporary new list (unselected first, then rest) // which replaces the existing one, to avoid the need of an additional sort column TQValueList<TQListViewItem*> newlist; TQListViewItem* item = gui->ListViewSelected->firstChild(); TQListViewItem* nextitem = NULL; // kdDebug() << "Filling new list with unselected items first" << endl; while (item) { // kdDebug() << " processing item " << item->text(0) << endl; nextitem = item->nextSibling(); if (!item->isSelected()) { newlist.prepend(item); gui->ListViewSelected->takeItem(item); } item = nextitem; } // kdDebug() << "Appending the rest" << endl; item = gui->ListViewSelected->firstChild(); while (item) { nextitem = item->nextSibling(); if (item->isSelected()) { newlist.prepend(item); gui->ListViewSelected->takeItem(item); } item = nextitem; } // kdDebug() << "Refill the view with the correctly ordered list" << endl; //the view is empty now, refill in correct order (reversed!!) TQValueList<TQListViewItem*>::iterator it; for (it = newlist.begin(); it != newlist.end(); ++it) { // kdDebug() << " adding " << (*it)->text(0) << endl; gui->ListViewSelected->insertItem(*it); } } /***************************************************************************** * * View * *****************************************************************************/ View::View( TQWidget *_parent, const char *_name, Doc *_doc ) : KoView( _doc, _parent, _name ) { ElapsedTime et( "View constructor" ); kdDebug(36001) << "sizeof(Cell)=" << sizeof(Cell) <<endl; d = new Private; d->view = this; d->doc = _doc; d->dcop = 0; d->activeSheet = 0; d->toolbarLock = false; d->loading = true; d->selection = new Selection( this ); d->choice = new Selection( this ); d->choice->setMultipleSelection(true); connect(d->selection, TQT_SIGNAL(changed(const Region&)), this, TQT_SLOT(slotChangeSelection(const Region&))); connect(d->choice, TQT_SIGNAL(changed(const Region&)), this, TQT_SLOT(slotChangeChoice(const Region&))); connect(d->choice, TQT_SIGNAL(changed(const Region&)), this, TQT_SLOT(slotScrollChoice(const Region&))); d->findOptions = 0; d->findLeftColumn = 0; d->findRightColumn = 0; d->typeValue = FindOption::Value; d->directionValue = FindOption::Row; d->find = 0; d->replace = 0; d->popupMenuFirstToolId = 0; d->popupMenu = 0; d->popupColumn = 0; d->popupRow = 0; d->popupChild = 0; d->popupListChoose = 0; d->popupChildObject = 0; d->searchInSheets.currentSheet = 0; d->searchInSheets.firstSheet = 0; // spell-check context d->spell.kspell = 0; d->spell.macroCmdSpellCheck = 0; d->spell.firstSpellSheet = 0; d->spell.currentSpellSheet = 0; d->spell.currentCell = 0; d->spell.spellStartCellX = 0; d->spell.spellStartCellY = 0; d->spell.spellEndCellX = 0; d->spell.spellEndCellY = 0; d->spell.spellCheckSelection = false; d->insertHandler = 0L; d->specialCharDlg = 0; setInstance( Factory::global() ); if ( doc()->isReadWrite() ) setXMLFile( "kspread.rc" ); else setXMLFile( "kspread_readonly.rc" ); // build the DCOP object dcopObject(); connect( doc()->commandHistory(), TQT_SIGNAL( commandExecuted() ), this, TQT_SLOT( commandExecuted() ) ); // GUI Initializations initView(); d->initActions(); // Handler for moving and resizing embedded parts KoContainerHandler* h = new KoContainerHandler( this, d->canvas ); connect( h, TQT_SIGNAL( popupMenu( KoChild*, const TQPoint& ) ), this, TQT_SLOT( popupChildMenu( KoChild*, const TQPoint& ) ) ); connect( this, TQT_SIGNAL( childSelected( KoDocumentChild* ) ), this, TQT_SLOT( slotChildSelected( KoDocumentChild* ) ) ); connect( this, TQT_SIGNAL( childUnselected( KoDocumentChild* ) ), this, TQT_SLOT( slotChildUnselected( KoDocumentChild* ) ) ); // If a selected part becomes active this is like it is deselected // just before. connect( this, TQT_SIGNAL( childActivated( KoDocumentChild* ) ), this, TQT_SLOT( slotChildUnselected( KoDocumentChild* ) ) ); connect( d->canvas, TQT_SIGNAL( objectSelectedChanged() ), this, TQT_SLOT( objectSelectedChanged() ) ); TQT_BASE_OBJECT_NAME::connect( doc()->map(), TQT_SIGNAL( sig_addSheet( Sheet* ) ), TQT_SLOT( slotAddSheet( Sheet* ) ) ); TQT_BASE_OBJECT_NAME::connect( doc(), TQT_SIGNAL( sig_refreshView( ) ), this, TQT_SLOT( slotRefreshView() ) ); TQT_BASE_OBJECT_NAME::connect( doc(), TQT_SIGNAL( sig_refreshLocale() ), this, TQT_SLOT( refreshLocale())); TQT_BASE_OBJECT_NAME::connect( doc(), TQT_SIGNAL( sig_addAreaName( const TQString & ) ), d->posWidget, TQT_SLOT( slotAddAreaName( const TQString & ) ) ); TQT_BASE_OBJECT_NAME::connect( doc(), TQT_SIGNAL( sig_removeAreaName( const TQString & ) ), d->posWidget, TQT_SLOT( slotRemoveAreaName( const TQString & ) ) ); TQT_BASE_OBJECT_NAME::connect( doc(), TQT_SIGNAL( damagesFlushed( const TQValueList<Damage*>& ) ), this, TQT_SLOT( handleDamages( const TQValueList<Damage*>& ) ) ); //KoView::setZoom( doc()->zoomedResolutionY() /* KoView only supports one zoom */ ); // initial value //when kspread is embedded into konqueror apply a zoom=100 //in konqueror we can't change zoom -- ### TODO ? if (!doc()->isReadWrite()) { setZoom( 100, true ); } viewZoom( TQString::number( doc()->zoom() ) ); // ## Might be wrong, if doc isn't loaded yet d->actions->selectStyle->setItems( d->doc->styleManager()->styleNames() ); // Delay the setting of the initial position, because // we have to wait for the widget to be shown. Otherwise, // we get a wrong widget size. // This is the last operation for the "View loading" process. // The loading flag will be unset at its end. if ( !doc()->map()->sheetList().isEmpty() ) TQTimer::singleShot(50, this, TQT_SLOT(initialPosition())); connect (&d->statusBarOpTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(calcStatusBarOp())); } View::~View() { // ElapsedTime el( "~View" ); if ( doc()->isReadWrite() ) // make sure we're not embedded in Konq deleteEditor( true ); if ( !d->transformToolBox.isNull() ) delete (&*d->transformToolBox); /*if (d->calcLabel) { disconnect(d->calcLabel,TQT_SIGNAL(pressed( int )),this,TQT_SLOT(statusBarClicked(int))); }*/ delete d->spell.kspell; d->canvas->endChoose(); d->activeSheet = 0; // set the active sheet to 0L so that when during destruction // of embedded child documents possible repaints in Sheet are not // performed. The repains can happen if you delete an embedded document, // which leads to an regionInvalidated() signal emission in KoView, which calls // repaint, etc.etc. :-) (Simon) delete d->selection; delete d->choice; delete d->popupColumn; delete d->popupRow; delete d->popupMenu; delete d->popupChild; delete d->popupListChoose; delete d->calcLabel; delete d->dcop; delete d->insertHandler; d->insertHandler = 0L; delete d->actions; // NOTE Stefan: Delete the Canvas explicitly, even if it has this view as // parent. Otherwise, it leads to crashes, because it tries to // access this View in some events (Bug #126492). delete d->canvas; delete d; } Doc* View::doc() const { return d->doc; } // should be called only once, from the constructor /* * Top part is the formula bar. * Central part is the canvas, row header and vertical scrollbar. * Bottom part is the tab bar and horizontal scrollbar. * * Note that canvas must the one to be created, since other * widgets might depend on it. */ void View::initView() { d->viewLayout = new TQGridLayout( this, 3, 4 ); // Vert. Scroll Bar d->calcLabel = 0; d->vertScrollBar = new TQScrollBar( this, "ScrollBar_2" ); d->vertScrollBar->setRange( 0, 4096 ); d->vertScrollBar->setOrientation( Qt::Vertical ); d->vertScrollBar->setLineStep(60); //just random guess based on what feels okay d->vertScrollBar->setPageStep(60); //This should be controlled dynamically, depending on how many rows are shown // Edit Bar d->toolWidget = new TQFrame( this ); d->formulaBarLayout = new TQHBoxLayout( d->toolWidget ); d->formulaBarLayout->setMargin( 4 ); d->formulaBarLayout->addSpacing( 2 ); d->posWidget = new ComboboxLocationEditWidget( d->toolWidget, this ); d->posWidget->setMinimumWidth( 100 ); d->formulaBarLayout->addWidget( d->posWidget ); d->formulaBarLayout->addSpacing( 6 ); d->formulaButton = d->newIconButton( "funct", true, d->toolWidget ); d->formulaBarLayout->addWidget( d->formulaButton ); d->formulaBarLayout->addSpacing( 2 ); connect( d->formulaButton, TQT_SIGNAL( clicked() ), TQT_SLOT( insertMathExpr() ) ); d->cancelButton = d->newIconButton( "cancel", true, d->toolWidget ); d->formulaBarLayout->addWidget( d->cancelButton ); d->okButton = d->newIconButton( "ok", true, d->toolWidget ); d->formulaBarLayout->addWidget( d->okButton ); d->formulaBarLayout->addSpacing( 6 ); // The widget on which we display the sheet d->canvas = new Canvas( this ); // The line-editor that appears above the sheet and allows to // edit the cells content. It knows about the two buttons. d->editWidget = new EditWidget( d->toolWidget, d->canvas, d->cancelButton, d->okButton ); d->editWidget->setFocusPolicy( TQ_StrongFocus ); d->formulaBarLayout->addWidget( d->editWidget, 2 ); d->formulaBarLayout->addSpacing( 2 ); d->canvas->setEditWidget( d->editWidget ); d->hBorderWidget = new HBorder( this, d->canvas,this ); d->vBorderWidget = new VBorder( this, d->canvas ,this ); d->hBorderWidget->setSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Minimum ); d->vBorderWidget->setSizePolicy( TQSizePolicy::Minimum, TQSizePolicy::Expanding ); d->canvas->setFocusPolicy( TQ_StrongFocus ); TQWidget::setFocusPolicy( TQ_StrongFocus ); setFocusProxy( d->canvas ); connect( this, TQT_SIGNAL( invalidated() ), d->canvas, TQT_SLOT( update() ) ); TQWidget* bottomPart = new TQWidget( this ); d->tabScrollBarLayout = new TQHBoxLayout( bottomPart ); d->tabScrollBarLayout->setAutoAdd( true ); d->tabBar = new KoTabBar( bottomPart ); d->horzScrollBar = new TQScrollBar( bottomPart, "ScrollBar_1" ); d->horzScrollBar->setRange( 0, 4096 ); d->horzScrollBar->setOrientation( Qt::Horizontal ); d->horzScrollBar->setLineStep(60); //just random guess based on what feels okay d->horzScrollBar->setPageStep(60); TQT_BASE_OBJECT_NAME::connect( d->tabBar, TQT_SIGNAL( tabChanged( const TQString& ) ), this, TQT_SLOT( changeSheet( const TQString& ) ) ); TQT_BASE_OBJECT_NAME::connect( d->tabBar, TQT_SIGNAL( tabMoved( unsigned, unsigned ) ), this, TQT_SLOT( moveSheet( unsigned, unsigned ) ) ); TQT_BASE_OBJECT_NAME::connect( d->tabBar, TQT_SIGNAL( contextMenu( const TQPoint& ) ), this, TQT_SLOT( popupTabBarMenu( const TQPoint& ) ) ); TQT_BASE_OBJECT_NAME::connect( d->tabBar, TQT_SIGNAL( doubleClicked() ), this, TQT_SLOT( slotRename() ) ); d->viewLayout->setColStretch( 1, 10 ); d->viewLayout->setRowStretch( 2, 10 ); d->viewLayout->addMultiCellWidget( d->toolWidget, 0, 0, 0, 2 ); d->viewLayout->addMultiCellWidget( d->hBorderWidget, 1, 1, 1, 2 ); d->viewLayout->addWidget( d->vBorderWidget, 2, 0 ); d->viewLayout->addWidget( d->canvas, 2, 1 ); d->viewLayout->addWidget( d->vertScrollBar, 2, 2 ); d->viewLayout->addMultiCellWidget( bottomPart, 3, 3, 0, 2 ); KStatusBar * sb = statusBar(); Q_ASSERT(sb); d->calcLabel = sb ? new KStatusBarLabel( TQString(), 0, sb ) : 0; addStatusBarItem( d->calcLabel, 0 ); if (d->calcLabel) connect(d->calcLabel ,TQT_SIGNAL(itemPressed( int )),this,TQT_SLOT(statusBarClicked(int))); // signal slot TQT_BASE_OBJECT_NAME::connect( d->vertScrollBar, TQT_SIGNAL( valueChanged(int) ), d->canvas, TQT_SLOT( slotScrollVert(int) ) ); TQT_BASE_OBJECT_NAME::connect( d->horzScrollBar, TQT_SIGNAL( valueChanged(int) ), d->canvas, TQT_SLOT( slotScrollHorz(int) ) ); } Canvas* View::canvasWidget() const { return d->canvas; } HBorder* View::hBorderWidget()const { return d->hBorderWidget; } VBorder* View::vBorderWidget()const { return d->vBorderWidget; } TQScrollBar* View::horzScrollBar()const { return d->horzScrollBar; } TQScrollBar* View::vertScrollBar()const { return d->vertScrollBar; } EditWidget* View::editWidget()const { return d->editWidget; } ComboboxLocationEditWidget* View::posWidget()const { return d->posWidget; } KoTabBar* View::tabBar() const { return d->tabBar; } bool View::isLoading() const { return d->loading; } Selection* View::selectionInfo() const { return d->selection; } Selection* View::choice() const { return d->choice; } void View::resetInsertHandle() { d->actions->insertChartFrame->setChecked( false ); // d->actions->insertPicture->setChecked( false ); d->insertHandler = 0; } bool View::isInsertingObject() { return d->insertHandler; } const Sheet* View::activeSheet() const { return d->activeSheet; } Sheet* View::activeSheet() { return d->activeSheet; } void View::initConfig() { KConfig *config = Factory::global()->config(); if ( config->hasGroup("Parameters" )) { config->setGroup( "Parameters" ); if ( !doc()->configLoadFromFile() ) doc()->setShowHorizontalScrollBar(config->readBoolEntry("Horiz ScrollBar",true)); if ( !doc()->configLoadFromFile() ) doc()->setShowVerticalScrollBar(config->readBoolEntry("Vert ScrollBar",true)); doc()->setShowColHeader(config->readBoolEntry("Column Header",true)); doc()->setShowRowHeader(config->readBoolEntry("Row Header",true)); if ( !doc()->configLoadFromFile() ) doc()->setCompletionMode((KGlobalSettings::Completion)config->readNumEntry("Completion Mode",(int)(KGlobalSettings::CompletionAuto))); doc()->setMoveToValue((KSpread::MoveTo)config->readNumEntry("Move",(int)(Bottom))); doc()->setIndentValue( config->readDoubleNumEntry( "Indent", 10.0 ) ); doc()->setTypeOfCalc((MethodOfCalc)config->readNumEntry("Method of Calc",(int)(SumOfNumber))); if ( !doc()->configLoadFromFile() ) doc()->setShowTabBar(config->readBoolEntry("Tabbar",true)); doc()->setShowMessageError(config->readBoolEntry( "Msg error" ,false) ); doc()->setShowFormulaBar(config->readBoolEntry("Formula bar",true)); doc()->setShowStatusBar(config->readBoolEntry("Status bar",true)); changeNbOfRecentFiles(config->readNumEntry("NbRecentFile",10)); //autosave value is stored as a minute. //but default value is stored as seconde. doc()->setAutoSave(config->readNumEntry("AutoSave",KoDocument::defaultAutoSave()/60)*60); doc()->setBackupFile( config->readBoolEntry("BackupFile",true)); } if ( config->hasGroup("KSpread Color" ) ) { config->setGroup( "KSpread Color" ); TQColor _col(TQt::lightGray); _col = config->readColorEntry("GridColor", &_col); doc()->setGridColor(_col); TQColor _pbCol(TQt::red); _pbCol = config->readColorEntry("PageBorderColor", &_pbCol); doc()->changePageBorderColor(_pbCol); } // Do we need a Page Layout in the congiguration file? Isn't this already in the template? Philipp /* if ( config->hasGroup("KSpread Page Layout" ) ) { config->setGroup( "KSpread Page Layout" ); if ( d->activeSheet->isEmpty()) { d->activeSheet->setPaperFormat((KoFormat)config->readNumEntry("Default size page",1)); d->activeSheet->setPaperQt::Orientation((KoOrientation)config->readNumEntry("Default orientation page",0)); d->activeSheet->setPaperUnit((KoUnit::Unit)config->readNumEntry("Default unit page",0)); } } */ initCalcMenu(); calcStatusBarOp(); } void View::changeNbOfRecentFiles(int _nb) { if (shell()) shell()->setMaxRecentItems( _nb ); } void View::initCalcMenu() { switch( doc()->getTypeOfCalc()) { case SumOfNumber: d->actions->calcSum->setChecked(true); break; case Min: d->actions->calcMin->setChecked(true); break; case Max: d->actions->calcMax->setChecked(true); break; case Average: d->actions->calcAverage->setChecked(true); break; case Count: d->actions->calcCount->setChecked(true); break; case CountA: d->actions->calcCountA->setChecked(true); break; case NoneCalc: d->actions->calcNone->setChecked(true); break; default : d->actions->calcSum->setChecked(true); break; } } void View::recalcWorkBook() { if (!activeSheet()) return; Sheet * tbl; doc()->emitBeginOperation( true ); for ( tbl = doc()->map()->firstSheet(); tbl != 0L; tbl = doc()->map()->nextSheet() ) { // bool b = tbl->getAutoCalc(); // tbl->setAutoCalc( true ); tbl->recalc( /*force recalculation = */ true); // tbl->setAutoCalc( b ); } doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::refreshLocale() { doc()->emitBeginOperation(true); Sheet *tbl; for ( tbl = doc()->map()->firstSheet(); tbl != 0L; tbl = doc()->map()->nextSheet() ) { tbl->updateLocale(); } doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::recalcWorkSheet() { if ( d->activeSheet != 0 ) { doc()->emitBeginOperation( true ); // bool b = d->activeSheet->getAutoCalc(); // d->activeSheet->setAutoCalc( true ); d->activeSheet->recalc( /*force recalculation = */ true); // d->activeSheet->setAutoCalc( b ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::extraSpelling() { if ( d->spell.kspell ) return; // Already in progress if (d->activeSheet == 0L) return; d->spell.macroCmdSpellCheck = 0L; d->spell.firstSpellSheet = d->activeSheet; d->spell.currentSpellSheet = d->spell.firstSpellSheet; TQRect selection = d->selection->selection(); // if nothing is selected, check every cell if (d->selection->isSingular()) { d->spell.spellStartCellX = 0; d->spell.spellStartCellY = 0; d->spell.spellEndCellX = 0; d->spell.spellEndCellY = 0; d->spell.spellCheckSelection = false; d->spell.currentCell = d->activeSheet->firstCell(); } else { d->spell.spellStartCellX = selection.left(); d->spell.spellStartCellY = selection.top(); d->spell.spellEndCellX = selection.right(); d->spell.spellEndCellY = selection.bottom(); d->spell.spellCheckSelection = true; d->spell.currentCell = 0L; // "-1" because X gets increased every time we go into spellCheckReady() d->spell.spellCurrCellX = d->spell.spellStartCellX - 1; d->spell.spellCurrCellY = d->spell.spellStartCellY; } startKSpell(); } void View::startKSpell() { if ( doc()->getKSpellConfig() ) { doc()->getKSpellConfig()->setIgnoreList( doc()->spellListIgnoreAll() ); doc()->getKSpellConfig()->setReplaceAllList( d->spell.replaceAll ); } d->spell.kspell = new KSpell( this, i18n( "Spell Checking" ), TQT_TQOBJECT(this), TQT_SLOT( spellCheckerReady() ), doc()->getKSpellConfig() ); d->spell.kspell->setIgnoreUpperWords( doc()->dontCheckUpperWord() ); d->spell.kspell->setIgnoreTitleCase( doc()->dontCheckTitleCase() ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( death() ), this, TQT_SLOT( spellCheckerFinished() ) ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( misspelling( const TQString &, const TQStringList &, unsigned int) ), this, TQT_SLOT( spellCheckerMisspelling( const TQString &, const TQStringList &, unsigned int) ) ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( corrected( const TQString &, const TQString &, unsigned int) ), this, TQT_SLOT( spellCheckerCorrected( const TQString &, const TQString &, unsigned int ) ) ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( done( const TQString & ) ), this, TQT_SLOT( spellCheckerDone( const TQString & ) ) ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( ignoreall (const TQString & ) ), this, TQT_SLOT( spellCheckerIgnoreAll( const TQString & ) ) ); TQT_BASE_OBJECT_NAME::connect( d->spell.kspell, TQT_SIGNAL( replaceall( const TQString & , const TQString & )), this, TQT_SLOT( spellCheckerReplaceAll( const TQString & , const TQString & ))); } void View::spellCheckerReplaceAll( const TQString &orig, const TQString & replacement) { d->spell.replaceAll.append( orig); d->spell.replaceAll.append( replacement); } void View::spellCheckerIgnoreAll( const TQString & word) { doc()->addIgnoreWordAll( word ); } void View::spellCheckerReady() { if (d->canvas) d->canvas->setCursor( WaitCursor ); // go on to the next cell if (!d->spell.spellCheckSelection) { // if nothing is selected we have to check every cell // we use a different way to make it faster while ( d->spell.currentCell ) { // check text only if ( d->spell.currentCell->value().isString() ) { d->spell.kspell->check( d->spell.currentCell->text(), true ); return; } d->spell.currentCell = d->spell.currentCell->nextCell(); if ( d->spell.currentCell && d->spell.currentCell->isDefault() ) kdDebug() << "checking default cell!!" << endl << endl; } if (spellSwitchToOtherSheet()) spellCheckerReady(); else spellCleanup(); return; } // if something is selected: ++d->spell.spellCurrCellX; if (d->spell.spellCurrCellX > d->spell.spellEndCellX) { d->spell.spellCurrCellX = d->spell.spellStartCellX; ++d->spell.spellCurrCellY; } unsigned int y; unsigned int x; for ( y = d->spell.spellCurrCellY; y <= d->spell.spellEndCellY; ++y ) { for ( x = d->spell.spellCurrCellX; x <= d->spell.spellEndCellX; ++x ) { Cell * cell = d->spell.currentSpellSheet->cellAt( x, y ); // check text only if (cell->isDefault() || !cell->value().isString()) continue; d->spell.spellCurrCellX = x; d->spell.spellCurrCellY = y; d->spell.kspell->check( cell->text(), true ); return; } d->spell.spellCurrCellX = d->spell.spellStartCellX; } // if the user selected something to be checked we are done // otherwise ask for checking the next sheet if any if (d->spell.spellCheckSelection) { // Done spellCleanup(); } else { if (spellSwitchToOtherSheet()) spellCheckerReady(); else spellCleanup(); } } void View::spellCleanup() { if ( d->canvas ) d->canvas->setCursor( ArrowCursor ); d->spell.kspell->cleanUp(); delete d->spell.kspell; d->spell.kspell = 0L; d->spell.firstSpellSheet = 0L; d->spell.currentSpellSheet = 0L; d->spell.currentCell = 0L; d->spell.replaceAll.clear(); KMessageBox::information( this, i18n( "Spell checking is complete." ) ); if ( d->spell.macroCmdSpellCheck ) doc()->addCommand( d->spell.macroCmdSpellCheck ); d->spell.macroCmdSpellCheck=0L; } bool View::spellSwitchToOtherSheet() { // there is no other sheet if ( doc()->map()->count() == 1 ) return false; // for optimization TQPtrList<Sheet> sheetList = doc()->map()->sheetList(); unsigned int curIndex = sheetList.findRef(d->spell.currentSpellSheet); ++curIndex; // last sheet? then start at the beginning if ( curIndex >= sheetList.count() ) d->spell.currentSpellSheet = sheetList.first(); else d->spell.currentSpellSheet = sheetList.at(curIndex); // if the current sheet is the first one again, we are done. if ( d->spell.currentSpellSheet == d->spell.firstSpellSheet ) { setActiveSheet( d->spell.firstSpellSheet ); return false; } if (d->spell.spellCheckSelection) { d->spell.spellEndCellX = d->spell.currentSpellSheet->maxColumn(); d->spell.spellEndCellY = d->spell.currentSpellSheet->maxRow(); d->spell.spellCurrCellX = d->spell.spellStartCellX - 1; d->spell.spellCurrCellY = d->spell.spellStartCellY; } else { d->spell.currentCell = d->spell.currentSpellSheet->firstCell(); } if ( KMessageBox::questionYesNo( this, i18n( "Do you want to check the spelling in the next sheet?") ) != KMessageBox::Yes ) return false; setActiveSheet( d->spell.currentSpellSheet ); return true; } void View::spellCheckerMisspelling( const TQString &, const TQStringList &, unsigned int ) { // scroll to the cell if ( !d->spell.spellCheckSelection ) { d->spell.spellCurrCellX = d->spell.currentCell->column(); d->spell.spellCurrCellY = d->spell.currentCell->row(); } d->selection->initialize(TQPoint(d->spell.spellCurrCellX, d->spell.spellCurrCellY)); } void View::spellCheckerCorrected( const TQString & old, const TQString & corr, unsigned int pos ) { Cell * cell; if (d->spell.spellCheckSelection) { cell = d->spell.currentSpellSheet->cellAt( d->spell.spellCurrCellX, d->spell.spellCurrCellY ); } else { cell = d->spell.currentCell; d->spell.spellCurrCellX = cell->column(); d->spell.spellCurrCellY = cell->row(); } Q_ASSERT( cell ); if ( !cell ) return; doc()->emitBeginOperation(false); TQString content( cell->text() ); UndoSetText* undo = new UndoSetText( doc(), d->activeSheet, content, d->spell.spellCurrCellX, d->spell.spellCurrCellY, cell->formatType()); content.replace( pos, old.length(), corr ); cell->setCellText( content ); d->editWidget->setText( content ); if ( !d->spell.macroCmdSpellCheck ) d->spell.macroCmdSpellCheck = new MacroUndoAction( doc(), i18n("Correct Misspelled Word") ); d->spell.macroCmdSpellCheck->addCommand( undo ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::spellCheckerDone( const TQString & ) { int result = d->spell.kspell->dlgResult(); d->spell.kspell->cleanUp(); delete d->spell.kspell; d->spell.kspell = 0L; if ( result != KS_CANCEL && result != KS_STOP ) { if (d->spell.spellCheckSelection) { if ( (d->spell.spellCurrCellY <= d->spell.spellEndCellY) && (d->spell.spellCurrCellX <= d->spell.spellEndCellX) ) { startKSpell(); return; } } else { if ( d->spell.currentCell ) { d->spell.currentCell = d->spell.currentCell->nextCell(); startKSpell(); return; } } } d->spell.replaceAll.clear(); if ( d->spell.macroCmdSpellCheck ) { doc()->addCommand( d->spell.macroCmdSpellCheck ); } d->spell.macroCmdSpellCheck=0L; } void View::spellCheckerFinished() { if (d->canvas) d->canvas->setCursor( ArrowCursor ); KSpell::spellStatus status = d->spell.kspell->status(); d->spell.kspell->cleanUp(); delete d->spell.kspell; d->spell.kspell = 0L; d->spell.replaceAll.clear(); bool kspellNotConfigured=false; if (status == KSpell::Error) { KMessageBox::sorry(this, i18n("ISpell could not be started.\n" "Please make sure you have ISpell properly configured and in your PATH.")); kspellNotConfigured=true; } else if (status == KSpell::Crashed) { KMessageBox::sorry(this, i18n("ISpell seems to have crashed.")); } if (d->spell.macroCmdSpellCheck) { doc()->addCommand( d->spell.macroCmdSpellCheck ); } d->spell.macroCmdSpellCheck=0L; if (kspellNotConfigured) { PreferenceDialog configDlg( this, 0 ); configDlg.openPage( PreferenceDialog::KS_SPELLING); configDlg.exec(); } } void View::initialPosition() { // Loading completed, pick initial worksheet TQPtrListIterator<Sheet> it( doc()->map()->sheetList() ); for( ; it.current(); ++it ) addSheet( it.current() ); // Set the initial X and Y offsets for the view (OpenDocument loading) if ( KSPLoadingInfo* loadingInfo = doc()->loadingInfo() ) { d->savedAnchors = loadingInfo->cursorPositions(); d->savedMarkers = loadingInfo->cursorPositions(); d->savedOffsets = loadingInfo->scrollingOffsets(); } Sheet * tbl = 0L; if ( doc()->isEmbedded() ) { tbl = doc()->displaySheet(); } if ( !tbl ) tbl = doc()->map()->initialActiveSheet(); if ( tbl ) setActiveSheet( tbl ); else { //activate first table which is not hiding tbl = doc()->map()->findSheet( doc()->map()->visibleSheets().first()); if ( !tbl ) { tbl = doc()->map()->firstSheet(); if ( tbl ) { tbl->setHidden( false ); TQString tabName = tbl->sheetName(); d->tabBar->addTab( tabName ); } } setActiveSheet( tbl ); } refreshView(); // Set the initial X and Y offsets for the view (Native format loading) if ( !doc()->loadingInfo() ) { double offsetX = doc()->map()->initialXOffset(); double offsetY = doc()->map()->initialYOffset(); // Set the initial position for the marker as stored in the XML file, // (1,1) otherwise int col = doc()->map()->initialMarkerColumn(); if ( col <= 0 ) col = 1; int row = doc()->map()->initialMarkerRow(); if ( row <= 0 ) row = 1; d->canvas->setXOffset( offsetX ); d->canvas->setYOffset( offsetY ); d->horzScrollBar->setValue( (int)offsetX ); d->vertScrollBar->setValue( (int)offsetY ); d->selection->initialize( TQPoint(col, row) ); } updateBorderButton(); updateShowSheetMenu(); d->actions->autoFormat->setEnabled(false); d->actions->sort->setEnabled(false); d->actions->mergeCell->setEnabled(false); d->actions->mergeCellHorizontal->setEnabled(false); d->actions->mergeCellVertical->setEnabled(false); d->actions->createStyle->setEnabled(false); d->actions->fillUp->setEnabled( false ); d->actions->fillRight->setEnabled( false ); d->actions->fillDown->setEnabled( false ); d->actions->fillLeft->setEnabled( false ); // make paint effective: doc()->decreaseNumOperation(); TQRect vr( activeSheet()->visibleRect( d->canvas ) ); doc()->emitBeginOperation( false ); activeSheet()->setRegionPaintDirty( vr ); doc()->emitEndOperation( vr ); if ( koDocument()->isReadWrite() ) initConfig(); d->adjustActions( !d->activeSheet->isProtected() ); d->adjustWorkbookActions( !doc()->map()->isProtected() ); // finish the "View Loading" process d->loading = false; doc()->deleteLoadingInfo(); } void View::updateEditWidgetOnPress() { if (!d->activeSheet) return; int column = d->canvas->markerColumn(); int row = d->canvas->markerRow(); Cell* cell = d->activeSheet->cellAt( column, row ); if ( !cell ) { d->editWidget->setText( "" ); return; } if ( d->activeSheet->isProtected() && cell->format()->isHideFormula( column, row ) ) d->editWidget->setText( cell->strOutText() ); else if ( d->activeSheet->isProtected() && cell->format()->isHideAll( column, row ) ) d->editWidget->setText( "" ); else d->editWidget->setText( cell->text() ); d->updateButton(cell, column, row); d->adjustActions( d->activeSheet, cell ); } void View::updateEditWidget() { if (!d->activeSheet) return; int column = d->canvas->markerColumn(); int row = d->canvas->markerRow(); Cell * cell = d->activeSheet->cellAt( column, row ); bool active = activeSheet()->getShowFormula() && !( d->activeSheet->isProtected() && cell && cell->format()->isHideFormula( column, row ) ); if ( d->activeSheet && !d->activeSheet->isProtected() ) { d->actions->alignLeft->setEnabled(!active); d->actions->alignCenter->setEnabled(!active); d->actions->alignRight->setEnabled(!active); } if ( !cell ) { d->editWidget->setText( "" ); if ( d->activeSheet->isProtected() ) d->editWidget->setEnabled( false ); else d->editWidget->setEnabled( true ); return; } if ( d->activeSheet->isProtected() && cell->format()->isHideFormula( column, row ) ) d->editWidget->setText( cell->strOutText() ); else if ( d->activeSheet->isProtected() && cell->format()->isHideAll( column, row ) ) d->editWidget->setText( "" ); else d->editWidget->setText( cell->text() ); if ( d->activeSheet->isProtected() && !cell->format()->notProtected( column, row ) ) d->editWidget->setEnabled( false ); else d->editWidget->setEnabled( true ); if ( d->canvas->editor() ) { d->canvas->editor()->setEditorFont(cell->format()->textFont(column, row), true); d->canvas->editor()->setFocus(); } d->updateButton(cell, column, row); d->adjustActions( d->activeSheet, cell ); } void View::activateFormulaEditor() { } void View::objectSelectedChanged() { if ( d->canvas->isObjectSelected() ) d->actions->actionExtraProperties->setEnabled( true ); else d->actions->actionExtraProperties->setEnabled( false ); } void View::updateReadWrite( bool readwrite ) { // d->cancelButton->setEnabled( readwrite ); // d->okButton->setEnabled( readwrite ); d->editWidget->setEnabled( readwrite ); TQValueList<KAction*> actions = actionCollection()->actions(); TQValueList<KAction*>::ConstIterator aIt = actions.begin(); TQValueList<KAction*>::ConstIterator aEnd = actions.end(); for (; aIt != aEnd; ++aIt ) (*aIt)->setEnabled( readwrite ); // d->actions->transform->setEnabled( false ); if ( !doc() || !doc()->map() || doc()->map()->isProtected() ) { d->actions->showSheet->setEnabled( false ); d->actions->hideSheet->setEnabled( false ); } else { d->actions->showSheet->setEnabled( true ); d->actions->hideSheet->setEnabled( true ); } d->actions->gotoCell->setEnabled( true ); d->actions->viewZoom->setEnabled( true ); d->actions->showPageBorders->setEnabled( true ); d->actions->find->setEnabled( true); d->actions->replace->setEnabled( readwrite ); if ( !doc()->isReadWrite()) d->actions->copy->setEnabled( true ); // d->actions->newView->setEnabled( true ); //doc()->KXMLGUIClient::action( "newView" )->setEnabled( true ); // obsolete (Werner) } void View::createTemplate() { int width = 60; int height = 60; TQPixmap pix = doc()->generatePreview(TQSize(width, height)); KTempFile tempFile( TQString(), ".kst" ); //Check that creation of temp file was successful if (tempFile.status() != 0) { tqWarning("Creation of temprary file to store template failed."); return; } tempFile.setAutoDelete(true); doc()->saveNativeFormat( tempFile.name() ); KoTemplateCreateDia::createTemplate( "kspread_template", Factory::global(), tempFile.name(), pix, this ); Factory::global()->dirs()->addResourceType("kspread_template", KStandardDirs::kde_default( "data" ) + "kspread/templates/"); } void View::sheetFormat() { FormatDialog dlg( this ); dlg.exec(); } void View::autoSum() { if (!activeSheet()) return; // ######## Torben: Make sure that this can not be called // when canvas has a running editor if ( d->canvas->editor() ) return; //Get the selected range and remove the current cell from it (as that is //where the result of the autosum will be stored - perhaps change //this behaviour??) Range rg; //rg.sheet=activeSheet(); TQRect sel = d->selection->selection(false); if (sel.height() > 1) { if (d->selection->marker().y()==sel.top()) sel.setTop(sel.top()+1); if (d->selection->marker().y()==sel.bottom()) sel.setBottom(sel.bottom()-1); } else { if (sel.width() > 1) { if (d->selection->marker().x()==sel.left()) sel.setLeft(sel.left()+1); if (d->selection->marker().x()==sel.right()) sel.setRight(sel.right()-1); } else { sel=TQRect(); // only 1 cell selected // try to automagically find cells the user wants to sum up int start = -1, end = -1; if ( (d->selection->marker().y() > 1) && activeSheet()->cellAt(d->selection->marker().x(), d->selection->marker().y()-1)->value().isNumber() ) { // check cells above the current one start = end = d->selection->marker().y()-1; for (start--; (start > 0) && activeSheet()->cellAt(d->selection->marker().x(), start)->value().isNumber(); start--) ; Point startPoint, endPoint; startPoint.setRow(start+1); startPoint.setColumn(d->selection->marker().x()); endPoint.setRow(end); endPoint.setColumn(d->selection->marker().x()); TQString str = Range(startPoint, endPoint).toString(); d->canvas->createEditor( Canvas::CellEditor , true , true ); d->canvas->editor()->setText("=SUM(" + str + ")"); d->canvas->editor()->setCursorPosition(5 + str.length()); return; } else if ( (d->selection->marker().x() > 1) && activeSheet()->cellAt(d->selection->marker().x()-1, d->selection->marker().y())->value().isNumber() ) { // check cells to the left of the current one start = end = d->selection->marker().x()-1; for (start--; (start > 0) && activeSheet()->cellAt(start, d->selection->marker().y())->value().isNumber(); start--) ; Point startPoint, endPoint; startPoint.setColumn(start+1); startPoint.setRow(d->selection->marker().y()); endPoint.setColumn(end); endPoint.setRow(d->selection->marker().y()); TQString str = Range(startPoint, endPoint).toString(); d->canvas->createEditor( Canvas::CellEditor , true , true ); d->canvas->editor()->setText("=SUM(" + str + ")"); d->canvas->editor()->setCursorPosition(5 + str.length()); return; } } } if ( (sel.width() > 1) && (sel.height() > 1) ) sel=TQRect(); rg.setRange(sel); d->canvas->createEditor( Canvas::CellEditor , true , true ); if ( (rg.range().isValid() ) && (!rg.range().isEmpty()) ) { d->canvas->editor()->setText( "=SUM("+rg.toString()+")" ); d->canvas->deleteEditor(true); } else { d->canvas->startChoose(); d->canvas->editor()->setText( "=SUM()" ); d->canvas->editor()->setCursorPosition( 5 ); } } /* void View::oszilloscope() { TQDialog* dlg = new OsziDlg( this ); dlg->show(); } */ void View::changeTextColor() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionTextColor( selectionInfo(), d->actions->textColor->color() ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::setSelectionTextColor(const TQColor &txtColor) { if (d->activeSheet != 0L) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionTextColor( selectionInfo(), txtColor ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::changeBackgroundColor() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionbgColor( selectionInfo(), d->actions->bgColor->color() ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::setSelectionBackgroundColor(const TQColor &bgColor) { if (d->activeSheet != 0L) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionbgColor( selectionInfo(), bgColor ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::changeBorderColor() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionBorderColor( selectionInfo(), d->actions->borderColor->color() ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::setSelectionBorderColor(const TQColor &bdColor) { if (d->activeSheet != 0L) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionBorderColor( selectionInfo(), bdColor ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::helpUsing() { kapp->invokeHelp( ); } void View::enableUndo( bool _b ) { KAction* action = actionCollection()->action( "office_undo" ); if( action ) action->setEnabled( _b ); } void View::enableRedo( bool _b ) { KAction* action = actionCollection()->action( "office_redo" ); if( action ) action->setEnabled( _b ); } void View::enableInsertColumn( bool _b ) { if ( d->activeSheet && !d->activeSheet->isProtected() ) d->actions->insertColumn->setEnabled( _b ); } void View::enableInsertRow( bool _b ) { if ( d->activeSheet && !d->activeSheet->isProtected() ) d->actions->insertRow->setEnabled( _b ); } void View::deleteColumn() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); TQRect r( d->selection->selection() ); d->activeSheet->removeColumn( r.left(), ( r.right()-r.left() ) ); updateEditWidget(); // Stefan: update the selection after deleting (a) column(s) d->selection->update(); TQRect vr( d->activeSheet->visibleRect( d->canvas ) ); vr.setLeft( r.left() ); doc()->emitEndOperation( vr ); } void View::deleteRow() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); TQRect r( d->selection->selection() ); d->activeSheet->removeRow( r.top(),(r.bottom()-r.top()) ); updateEditWidget(); // Stefan: update the selection after deleting (a) column(s) d->selection->update(); TQRect vr( d->activeSheet->visibleRect( d->canvas ) ); vr.setTop( r.top() ); doc()->emitEndOperation( vr ); } void View::insertColumn() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); TQRect r( d->selection->selection() ); d->activeSheet->insertColumn( r.left(), ( r.right()-r.left() ) ); updateEditWidget(); TQRect vr( d->activeSheet->visibleRect( d->canvas ) ); vr.setLeft( r.left() - 1 ); doc()->emitEndOperation( vr ); } void View::hideColumn() { if ( !d->activeSheet ) return; if ( d->selection->isRowSelected() ) { KMessageBox::error( this, i18n( "Area is too large." ) ); return; } d->activeSheet->hideColumn(*selectionInfo()); } void View::showColumn() { if ( !d->activeSheet ) return; ShowColRow dlg( this, "showCol", ShowColRow::Column ); dlg.exec(); } void View::showSelColumns() { if ( !d->activeSheet ) return; d->activeSheet->showColumn(*selectionInfo()); } void View::insertRow() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); TQRect r( d->selection->selection() ); d->activeSheet->insertRow( r.top(), ( r.bottom() - r.top() ) ); updateEditWidget(); TQRect vr( d->activeSheet->visibleRect( d->canvas ) ); vr.setTop( r.top() - 1 ); doc()->emitEndOperation( vr ); } void View::hideRow() { if ( !d->activeSheet ) return; if ( d->selection->isColumnSelected() ) { KMessageBox::error( this, i18n( "Area is too large." ) ); return; } d->activeSheet->hideRow(*selectionInfo()); } void View::showRow() { if ( !d->activeSheet ) return; ShowColRow dlg( this, "showRow", ShowColRow::Row ); dlg.exec(); } void View::showSelRows() { if ( !d->activeSheet ) return; d->activeSheet->showRow(*selectionInfo()); } void View::fontSelected( const TQString & _font ) { if ( d->toolbarLock ) return; doc()->emitBeginOperation(false); if ( d->activeSheet != 0L ) d->activeSheet->setSelectionFont( d->selection, _font.latin1() ); // Dont leave the focus in the toolbars combo box ... if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( d->selection->marker() ); d->canvas->editor()->setEditorFont( cell->format()->textFont( cell->column(), cell->row() ), true ); d->canvas->editor()->setFocus(); } else d->canvas->setFocus(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::decreaseFontSize() { setSelectionFontSize( -1 ); } void View::increaseFontSize() { setSelectionFontSize( 1 ); } void View::setSelectionFontSize( int size ) { if ( d->activeSheet != NULL ) { d->activeSheet->setSelectionSize( selectionInfo(), size ); } } void View::lower() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->setSelectionUpperLower( selectionInfo(), -1 ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::upper() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->setSelectionUpperLower( selectionInfo(), 1 ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::firstLetterUpper() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->setSelectionfirstLetterUpper( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::verticalText(bool b) { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->setSelectionVerticalText( selectionInfo(), b ); d->activeSheet->adjustArea(*selectionInfo()); updateEditWidget(); // TODO Stefan: nescessary? markSelectionAsDirty(); doc()->emitEndOperation(); } void View::insertSpecialChar() { TQString f( d->actions->selectFont->font() ); TQChar c = ' '; if ( d->specialCharDlg == 0 ) { d->specialCharDlg = new KoCharSelectDia( this, "insert special char", f, c, false ); connect( d->specialCharDlg, TQT_SIGNAL( insertChar( TQChar, const TQString & ) ), this, TQT_SLOT( slotSpecialChar( TQChar, const TQString & ) ) ); connect( d->specialCharDlg, TQT_SIGNAL( finished() ), this, TQT_SLOT( slotSpecialCharDlgClosed() ) ); } d->specialCharDlg->show(); } void View::slotSpecialCharDlgClosed() { if ( d->specialCharDlg ) { disconnect( d->specialCharDlg, TQT_SIGNAL(insertChar(TQChar,const TQString &)), this, TQT_SLOT(slotSpecialChar(TQChar,const TQString &))); disconnect( d->specialCharDlg, TQT_SIGNAL( finished() ), this, TQT_SLOT( slotSpecialCharDlgClosed() ) ); d->specialCharDlg->deleteLater(); d->specialCharDlg = 0L; } } void View::slotSpecialChar( TQChar c, const TQString & _font ) { if ( d->activeSheet ) { TQPoint marker( d->selection->marker() ); Cell * cell = d->activeSheet->nonDefaultCell( marker ); if ( cell->format()->textFont( marker.x(), marker.y() ).family() != _font ) { cell->format()->setTextFontFamily( _font ); } EditWidget * edit = d->editWidget; TQKeyEvent ev( TQEvent::KeyPress, 0, 0, 0, TQString( c ) ); TQApplication::sendEvent( edit, &ev ); } } void View::insertMathExpr() { if ( d->activeSheet == 0L ) return; FormulaDialog * dlg = new FormulaDialog( this, "Function" ); dlg->show(); /* TODO - because I search on 'TODO's :-) */ // #### Is the dialog deleted when it's closed ? (David) // Torben thinks that not. } void View::formulaSelection( const TQString &_math ) { if ( d->activeSheet == 0 ) return; if ( _math == i18n("Others...") ) { insertMathExpr(); return; } FormulaDialog *dlg = new FormulaDialog( this, "Formula Editor", _math ); dlg->exec(); } void View::fontSizeSelected( int _size ) { if ( d->toolbarLock ) return; doc()->emitBeginOperation( false ); if ( d->activeSheet != 0L ) d->activeSheet->setSelectionFont( selectionInfo(), 0L, _size ); // Dont leave the focus in the toolbars combo box ... if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( d->selection->marker() ); d->canvas->editor()->setEditorFont( cell->format()->textFont( d->canvas->markerColumn(), d->canvas->markerRow() ), true ); d->canvas->editor()->setFocus(); } else d->canvas->setFocus(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::bold( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet == 0 ) return; doc()->emitBeginOperation( false ); int col = d->canvas->markerColumn(); int row = d->canvas->markerRow(); d->activeSheet->setSelectionFont( selectionInfo(), 0L, -1, b ); if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( col, row ); d->canvas->editor()->setEditorFont( cell->format()->textFont( col, row ), true ); } markSelectionAsDirty(); doc()->emitEndOperation(); } void View::underline( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet == 0 ) return; doc()->emitBeginOperation( false ); int col = d->canvas->markerColumn(); int row = d->canvas->markerRow(); d->activeSheet->setSelectionFont( selectionInfo(), 0L, -1, -1, -1 ,b ); if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( col, row ); d->canvas->editor()->setEditorFont( cell->format()->textFont( col, row ), true ); } markSelectionAsDirty(); doc()->emitEndOperation(); } void View::strikeOut( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet == 0 ) return; doc()->emitBeginOperation( false ); int col = d->canvas->markerColumn(); int row = d->canvas->markerRow(); d->activeSheet->setSelectionFont( selectionInfo(), 0L, -1, -1, -1 ,-1, b ); if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( col, row ); d->canvas->editor()->setEditorFont( cell->format()->textFont( col, row ), true ); } markSelectionAsDirty(); doc()->emitEndOperation(); } void View::italic( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet == 0 ) return; doc()->emitBeginOperation( false ); int col = d->canvas->markerColumn(); int row = d->canvas->markerRow(); d->activeSheet->setSelectionFont( selectionInfo(), 0L, -1, -1, b ); if ( d->canvas->editor() ) { Cell * cell = d->activeSheet->cellAt( col, row ); d->canvas->editor()->setEditorFont( cell->format()->textFont( col, row ), true ); } markSelectionAsDirty(); doc()->emitEndOperation(); } void View::sortInc() { if (!activeSheet()) return; TQRect range = d->selection->selection(); if ( d->selection->isSingular() ) { KMessageBox::error( this, i18n( "You must select multiple cells." ) ); return; } doc()->emitBeginOperation( false ); // Entire row(s) selected ? Or just one row ? if ( d->selection->isRowSelected() || range.top() == range.bottom() ) activeSheet()->sortByRow( range, range.top(), Sheet::Increase ); else activeSheet()->sortByColumn( range, range.left(), Sheet::Increase ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::sortDec() { TQRect range = d->selection->selection(); if ( d->selection->isSingular() ) { KMessageBox::error( this, i18n( "You must select multiple cells." ) ); return; } doc()->emitBeginOperation( false ); // Entire row(s) selected ? Or just one row ? if ( d->selection->isRowSelected() || range.top() == range.bottom() ) activeSheet()->sortByRow( range, range.top(), Sheet::Decrease ); else activeSheet()->sortByColumn( range, range.left(), Sheet::Decrease ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::borderBottom() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderBottom( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionBottomBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderBottom( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderRight() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) d->activeSheet->borderLeft( d->selection, d->actions->borderColor->color() ); else d->activeSheet->borderRight( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionRightBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) d->activeSheet->borderLeft( selectionInfo(), color ); else d->activeSheet->borderRight( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderLeft() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) d->activeSheet->borderRight( d->selection, d->actions->borderColor->color() ); else d->activeSheet->borderLeft( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionLeftBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) d->activeSheet->borderRight( selectionInfo(), color ); else d->activeSheet->borderLeft( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderTop() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderTop( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionTopBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderTop( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderOutline() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderOutline( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionOutlineBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderOutline( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderAll() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderAll( d->selection, d->actions->borderColor->color() ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::setSelectionAllBorderColor( const TQColor & color ) { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->borderAll( selectionInfo(), color ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::borderRemove() { if ( d->activeSheet != 0L ) { doc()->emitBeginOperation(false); d->activeSheet->borderRemove( d->selection ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::addSheet( Sheet * _t ) { doc()->emitBeginOperation( false ); insertSheet( _t ); // Connect some signals TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_refreshView() ), TQT_SLOT( slotRefreshView() ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateView( Sheet* ) ), TQT_SLOT( slotUpdateView( Sheet* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t->print(), TQT_SIGNAL( sig_updateView( Sheet* ) ), TQT_SLOT( slotUpdateView( Sheet* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateView( Sheet *, const Region& ) ), TQT_SLOT( slotUpdateView( Sheet*, const Region& ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateView( EmbeddedObject* )), TQT_SLOT( slotUpdateView( EmbeddedObject* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateHBorder( Sheet * ) ), TQT_SLOT( slotUpdateHBorder( Sheet * ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateVBorder( Sheet * ) ), TQT_SLOT( slotUpdateVBorder( Sheet * ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_nameChanged( Sheet*, const TQString& ) ), this, TQT_SLOT( slotSheetRenamed( Sheet*, const TQString& ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_SheetHidden( Sheet* ) ), this, TQT_SLOT( slotSheetHidden( Sheet* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_SheetShown( Sheet* ) ), this, TQT_SLOT( slotSheetShown( Sheet* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_SheetRemoved( Sheet* ) ), this, TQT_SLOT( slotSheetRemoved( Sheet* ) ) ); // ########### Why do these signals not send a pointer to the sheet? // This will lead to bugs. TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_updateChildGeometry( EmbeddedKOfficeObject* ) ), TQT_SLOT( slotUpdateChildGeometry( EmbeddedKOfficeObject* ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_maxColumn( int ) ), d->canvas, TQT_SLOT( slotMaxColumn( int ) ) ); TQT_BASE_OBJECT_NAME::connect( _t, TQT_SIGNAL( sig_maxRow( int ) ), d->canvas, TQT_SLOT( slotMaxRow( int ) ) ); if ( !d->loading ) updateBorderButton(); if ( !d->activeSheet ) { doc()->emitEndOperation(); return; } doc()->emitEndOperation( *selectionInfo() ); } void View::slotSheetRemoved( Sheet *_t ) { doc()->emitBeginOperation( false ); TQString m_sheetName=_t->sheetName(); d->tabBar->removeTab( _t->sheetName() ); if (doc()->map()->findSheet( doc()->map()->visibleSheets().first())) setActiveSheet( doc()->map()->findSheet( doc()->map()->visibleSheets().first() )); else d->activeSheet = 0L; TQValueList<Reference>::Iterator it; TQValueList<Reference> area=doc()->listArea(); for ( it = area.begin(); it != area.end(); ++it ) { //remove Area Name when sheet target is removed if ( (*it).sheet_name == m_sheetName ) { doc()->removeArea( (*it).ref_name ); //now area name is used in formula //so you must recalc sheets when remove areaname Sheet * tbl; for ( tbl = doc()->map()->firstSheet(); tbl != 0L; tbl = doc()->map()->nextSheet() ) { tbl->refreshRemoveAreaName((*it).ref_name); } } } doc()->emitEndOperation( *selectionInfo() ); } void View::removeAllSheets() { doc()->emitBeginOperation(false); d->tabBar->clear(); setActiveSheet( 0L ); doc()->emitEndOperation(); } void View::setActiveSheet( Sheet * _t, bool updateSheet ) { if ( _t == d->activeSheet ) return; doc()->emitBeginOperation(false); saveCurrentSheetSelection(); Sheet * oldSheet = d->activeSheet; d->activeSheet = _t; if ( d->activeSheet == 0L ) { doc()->emitEndOperation(); return; } if ( oldSheet && oldSheet->layoutDirection()==Sheet::RightToLeft != d->activeSheet->layoutDirection()==Sheet::RightToLeft ) refreshView(); doc()->setDisplaySheet( d->activeSheet ); if ( updateSheet ) { d->tabBar->setActiveTab( _t->sheetName() ); d->vBorderWidget->repaint(); d->hBorderWidget->repaint(); d->activeSheet->setRegionPaintDirty(TQRect(TQPoint(0,0), TQPoint(KS_colMax, KS_rowMax))); d->canvas->slotMaxColumn( d->activeSheet->maxColumn() ); d->canvas->slotMaxRow( d->activeSheet->maxRow() ); } d->actions->showPageBorders->setChecked( d->activeSheet->isShowPageBorders() ); d->actions->protectSheet->setChecked( d->activeSheet->isProtected() ); d->actions->protectDoc->setChecked( doc()->map()->isProtected() ); d->adjustActions( !d->activeSheet->isProtected() ); d->adjustWorkbookActions( !doc()->map()->isProtected() ); /* see if there was a previous selection on this other sheet */ TQMapIterator<Sheet*, TQPoint> it = d->savedAnchors.find(d->activeSheet); TQMapIterator<Sheet*, TQPoint> it2 = d->savedMarkers.find(d->activeSheet); TQMapIterator<Sheet*, KoPoint> it3 = d->savedOffsets.find(d->activeSheet); // TODO Stefan: store the save markers/anchors in the Selection? TQPoint newAnchor = (it == d->savedAnchors.end()) ? TQPoint(1,1) : *it; TQPoint newMarker = (it2 == d->savedMarkers.end()) ? TQPoint(1,1) : *it2; d->selection->clear(); d->selection->setSheet( d->activeSheet ); d->selection->initialize(TQRect(newMarker, newAnchor)); d->canvas->scrollToCell(newMarker); if (it3 != d->savedOffsets.end()) { d->canvas->setXOffset((*it3).x()); d->canvas->setYOffset((*it3).y()); d->horzScrollBar->setValue((int)(*it3).x()); d->vertScrollBar->setValue((int)(*it3).y()); } calcStatusBarOp(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::slotSheetRenamed( Sheet* sheet, const TQString& old_name ) { doc()->emitBeginOperation( false ); d->tabBar->renameTab( old_name, sheet->sheetName() ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::slotSheetHidden( Sheet* ) { doc()->emitBeginOperation(false); updateShowSheetMenu(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::slotSheetShown( Sheet* ) { doc()->emitBeginOperation(false); d->tabBar->setTabs( doc()->map()->visibleSheets() ); updateShowSheetMenu(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::changeSheet( const TQString& _name ) { if ( activeSheet()->sheetName() == _name ) return; Sheet *t = doc()->map()->findSheet( _name ); if ( !t ) { kdDebug(36001) << "Unknown sheet " << _name << endl; return; } doc()->emitBeginOperation(false); d->canvas->closeEditor(); // for selection mode setActiveSheet( t, false /* False: Endless loop because of setActiveTab() => do the visual area update manually*/); d->canvas->updateEditor(); // for choose mode updateEditWidget(); //refresh toggle button updateBorderButton(); //update visible area d->vBorderWidget->repaint(); d->hBorderWidget->repaint(); d->canvas->slotMaxColumn( d->activeSheet->maxColumn() ); d->canvas->slotMaxRow( d->activeSheet->maxRow() ); t->setRegionPaintDirty( t->visibleRect( d->canvas ) ); doc()->emitEndOperation(); } void View::moveSheet( unsigned sheet, unsigned target ) { if( doc()->map()->isProtected() ) return; TQStringList vs = doc()->map()->visibleSheets(); if( target >= vs.count() ) doc()->map()->moveSheet( vs[ sheet ], vs[ vs.count()-1 ], false ); else doc()->map()->moveSheet( vs[ sheet ], vs[ target ], true ); d->tabBar->moveTab( sheet, target ); } void View::sheetProperties() { // sanity check, shouldn't happen if( doc()->map()->isProtected() ) return; if( d->activeSheet->isProtected() ) return; bool directionChanged = false; SheetPropertiesDialog* dlg = new SheetPropertiesDialog( this ); dlg->setLayoutDirection( d->activeSheet->layoutDirection() ); dlg->setAutoCalc( d->activeSheet->getAutoCalc() ); dlg->setShowGrid( d->activeSheet->getShowGrid() ); dlg->setShowPageBorders( d->activeSheet->isShowPageBorders() ); dlg->setShowFormula( d->activeSheet->getShowFormula() ); dlg->setHideZero( d->activeSheet->getHideZero() ); dlg->setShowFormulaIndicator( d->activeSheet->getShowFormulaIndicator() ); dlg->setShowCommentIndicator( d->activeSheet->getShowCommentIndicator() ); dlg->setColumnAsNumber( d->activeSheet->getShowColumnNumber() ); dlg->setLcMode( d->activeSheet->getLcMode() ); dlg->setCapitalizeFirstLetter( d->activeSheet->getFirstLetterUpper() ); if( dlg->exec() ) { SheetPropertiesCommand* command = new SheetPropertiesCommand( doc(), d->activeSheet ); if ( d->activeSheet->layoutDirection() != dlg->layoutDirection() ) directionChanged = true; command->setLayoutDirection( dlg->layoutDirection() ); command->setAutoCalc( dlg->autoCalc() ); command->setShowGrid( dlg->showGrid() ); command->setShowPageBorders( dlg->showPageBorders() ); command->setShowFormula( dlg->showFormula() ); command->setHideZero( dlg->hideZero() ); command->setShowFormulaIndicator( dlg->showFormulaIndicator() ); command->setShowCommentIndicator( dlg->showCommentIndicator() ); command->setColumnAsNumber( dlg->columnAsNumber() ); command->setLcMode( dlg->lcMode() ); command->setCapitalizeFirstLetter( dlg->capitalizeFirstLetter() ); doc()->addCommand( command ); command->execute(); } delete dlg; if ( directionChanged ) { // the scrollbar and hborder remain reversed otherwise d->horzScrollBar->setValue( d->horzScrollBar->maxValue() - d->horzScrollBar->value() ); d->hBorderWidget->update(); } } void View::insertSheet() { if ( doc()->map()->isProtected() ) { KMessageBox::error( 0, i18n ( "You cannot change a protected sheet." ) ); return; } doc()->emitBeginOperation( false ); d->canvas->closeEditor(); Sheet * t = doc()->map()->createSheet(); KCommand* command = new AddSheetCommand( t ); doc()->addCommand( command ); updateEditWidget(); setActiveSheet( t ); if ( doc()->map()->visibleSheets().count() > 1 ) { d->actions->removeSheet->setEnabled( true ); d->actions->hideSheet->setEnabled( true ); } doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::hideSheet() { if ( !d->activeSheet ) return; if ( doc()->map()->visibleSheets().count() == 1) { KMessageBox::error( this, i18n("You cannot hide the last visible sheet.") ); return; } TQStringList vs = doc()->map()->visibleSheets(); int i = vs.findIndex( d->activeSheet->tableName() ) - 1; if( i < 0 ) i = 1; TQString sn = vs[i]; doc()->emitBeginOperation(false); KCommand* command = new HideSheetCommand( activeSheet() ); doc()->addCommand( command ); command->execute(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); d->tabBar->removeTab( d->activeSheet->sheetName() ); d->tabBar->setActiveTab( sn ); } void View::showSheet() { if ( !d->activeSheet ) return; ShowDialog dlg( this, "Sheet show"); dlg.exec(); } void View::copySelection() { if ( !d->activeSheet ) return; if ( canvasWidget()->isObjectSelected() ) { canvasWidget()->copyOasisObjects(); return; } if ( !d->canvas->editor() ) { d->activeSheet->copySelection( selectionInfo() ); updateEditWidget(); } else d->canvas->editor()->copy(); } void View::copyAsText() { if ( !d->activeSheet ) return; d->activeSheet->copyAsText( selectionInfo() ); } void View::cutSelection() { if ( !d->activeSheet ) return; //don't used this function when we edit a cell. doc()->emitBeginOperation(false); if ( canvasWidget()->isObjectSelected() ) { canvasWidget()->copyOasisObjects(); markSelectionAsDirty(); doc()->emitEndOperation(); KMacroCommand * macroCommand = 0L; TQPtrListIterator<EmbeddedObject> it( doc()->embeddedObjects() ); for ( ; it.current() ; ++it ) { if ( it.current()->sheet() == canvasWidget()->activeSheet() && it.current()->isSelected() ) { if( !macroCommand ) macroCommand = new KMacroCommand( i18n( "Cut Objects" ) ); RemoveObjectCommand *cmd = new RemoveObjectCommand( it.current(), true ); macroCommand->addCommand( cmd ); } } if ( macroCommand ) { doc()->addCommand( macroCommand ); canvasWidget()->setMouseSelectedObject( false ); macroCommand->execute(); } return; } if ( !d->canvas->editor()) { d->activeSheet->cutSelection( selectionInfo() ); calcStatusBarOp(); updateEditWidget(); } else d->canvas->editor()->cut(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::paste() { if ( !d->activeSheet ) return; if (!koDocument()->isReadWrite()) // don't paste into a read only document return; TQMimeSource *data = TQApplication::clipboard()->data( TQClipboard::Clipboard ); for ( int i=0; data->format(i) != 0; i++ ) kdDebug() << "format:" << data->format(i) << endl; if ( data->provides( KoStoreDrag::mimeType("application/vnd.oasis.opendocument.spreadsheet" ) )) { canvasWidget()->deselectAllObjects(); TQCString returnedTypeMime = "application/vnd.oasis.opendocument.spreadsheet"; const TQByteArray arr = data->encodedData( returnedTypeMime ); if( arr.isEmpty() ) return; TQBuffer buffer( arr ); KoStore * store = KoStore::createStore( TQT_TQIODEVICE(&buffer), KoStore::Read ); KoOasisStore oasisStore( store ); TQDomDocument doc; TQString errorMessage; bool ok = oasisStore.loadAndParse( "content.xml", doc, errorMessage ); if ( !ok ) { kdError(32001) << "Error parsing content.xml: " << errorMessage << endl; return; } KoOasisStyles oasisStyles; TQDomDocument stylesDoc; (void)oasisStore.loadAndParse( "styles.xml", stylesDoc, errorMessage ); // Load styles from style.xml oasisStyles.createStyleMap( stylesDoc, true ); // Also load styles from content.xml oasisStyles.createStyleMap( doc, false ); // from KSpreadDoc::loadOasis: TQDomElement content = doc.documentElement(); TQDomElement realBody ( KoDom::namedItemNS( content, KoXmlNS::office, "body" ) ); if ( realBody.isNull() ) { kdDebug() << "Invalid OASIS OpenDocument file. No office:body tag found." << endl; return; } TQDomElement body = KoDom::namedItemNS( realBody, KoXmlNS::office, "spreadsheet" ); if ( body.isNull() ) { kdError(32001) << "No office:spreadsheet found!" << endl; TQDomElement childElem; TQString localName; forEachElement( childElem, realBody ) { localName = childElem.localName(); } return; } KoOasisLoadingContext context( d->doc, oasisStyles, store ); Q_ASSERT( !oasisStyles.officeStyle().isNull() ); //load in first d->doc->styleManager()->loadOasisStyleTemplate( oasisStyles ); // // TODO check versions and mimetypes etc. d->doc->loadOasisAreaName( body ); d->doc->loadOasisCellValidation( body ); // all <sheet:sheet> goes to workbook bool result = d->doc->map()->loadOasis( body, context ); if (!result) return; } else { //TODO: What if the clipboard data is available in both pixmap and OASIS format? (ie. for embedded parts) TQPixmap clipboardPixmap = TQApplication::clipboard()->pixmap( TQClipboard::Clipboard ); if (!clipboardPixmap.isNull()) { d->activeSheet->insertPicture( markerDocumentPosition() , clipboardPixmap ); } } doc()->emitBeginOperation( false ); if ( !d->canvas->editor() ) { //kdDebug(36001) << "Pasting. Rect= " << d->selection->selection(false) << " bytes" << endl; d->activeSheet->paste( d->selection->lastRange(), true, Paste::Normal, Paste::OverWrite, false, 0, true ); calcStatusBarOp(); updateEditWidget(); } else { d->canvas->editor()->paste(); } doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::specialPaste() { if ( !d->activeSheet ) return; SpecialDialog dlg( this, "Special Paste" ); if ( dlg.exec() ) { if ( d->activeSheet->getAutoCalc() ) { doc()->emitBeginOperation( false ); d->activeSheet->recalc(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } calcStatusBarOp(); updateEditWidget(); } } void View::removeComment() { if ( !d->activeSheet ) return; doc()->emitBeginOperation(false); d->activeSheet->setSelectionRemoveComment( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::changeAngle() { if ( !d->activeSheet ) return; AngleDialog dlg( this, "Angle" , TQPoint( d->canvas->markerColumn(), d->canvas->markerRow() )); if ( dlg.exec() ) { //TODO Stefan: where is the angle operation? d->activeSheet->adjustArea(*selectionInfo()); } } void View::setSelectionAngle( int angle ) { doc()->emitBeginOperation( false ); if ( d->activeSheet != NULL ) { d->activeSheet->setSelectionAngle( selectionInfo(), angle ); d->activeSheet->adjustArea(*selectionInfo()); } markSelectionAsDirty(); doc()->emitEndOperation(); } void View::mergeCell() { // sanity check if( !d->activeSheet ) return; d->activeSheet->mergeCells(*selectionInfo()); } void View::mergeCellHorizontal() { // sanity check if( !d->activeSheet ) return; d->activeSheet->mergeCells(*selectionInfo(), true); } void View::mergeCellVertical() { // sanity check if( !d->activeSheet ) return; d->activeSheet->mergeCells(*selectionInfo(), false, true); } void View::dissociateCell() { // sanity check if( !d->activeSheet ) return; d->activeSheet->dissociateCells(*selectionInfo()); } void View::increaseIndent() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->increaseIndent( d->selection ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::decreaseIndent() { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); int column = d->canvas->markerColumn(); int row = d->canvas->markerRow(); d->activeSheet->decreaseIndent( d->selection ); Cell * cell = d->activeSheet->cellAt( column, row ); if ( cell ) if ( !d->activeSheet->isProtected() ) d->actions->decreaseIndent->setEnabled( cell->format()->getIndent( column, row ) > 0.0 ); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::goalSeek() { if ( d->canvas->editor() ) { d->canvas->deleteEditor( true ); // save changes } GoalSeekDialog * dlg = new GoalSeekDialog( this, TQPoint( d->canvas->markerColumn(), d->canvas->markerRow() ), "GoalSeekDialog" ); dlg->show(); /* dialog autodeletes itself */ } void View::subtotals() { if (!activeSheet()) return; TQRect selection( d->selection->selection() ); if ( ( selection.width() < 2 ) || ( selection.height() < 2 ) ) { KMessageBox::error( this, i18n("You must select multiple cells.") ); return; } SubtotalDialog dlg(this, selection, "SubtotalDialog" ); if ( dlg.exec() ) { doc()->emitBeginOperation( false ); d->selection->initialize( TQRect(dlg.selection().topLeft(), dlg.selection().bottomRight()));//, dlg.sheet() ); doc()->emitEndOperation( selection ); } } void View::multipleOperations() { if ( d->canvas->editor() ) { d->canvas->deleteEditor( true ); // save changes } // MultipleOpDlg * dlg = new MultipleOpDlg( this, "MultipleOpDlg" ); // dlg->show(); } void View::textToColumns() { if (!activeSheet()) return; d->canvas->closeEditor(); TQRect area=d->selection->selection(); //Only use the first column area.setRight(area.left()); /* if ( area.width() > 1 ) { //Only use the first column KMessageBox::error( this, i18n("You must not select an area containing more than one column.") ); return; }*/ CSVDialog dialog( this, "CSVDialog", area, CSVDialog::Column ); if( !dialog.cancelled() ) dialog.exec(); } void View::consolidate() { d->canvas->closeEditor(); ConsolidateDialog * dlg = new ConsolidateDialog( this, "ConsolidateDialog" ); dlg->show(); // dlg destroys itself } void View::sortList() { if (!activeSheet()) return; ListDialog dlg( this, "List selection" ); dlg.exec(); } void View::gotoCell() { if (!activeSheet()) return; GotoDialog dlg( this, "GotoCell" ); dlg.exec(); } void View::find() { if (!activeSheet()) return; FindDlg dlg( this, "Find", d->findOptions, d->findStrings ); dlg.setHasSelection( !d->selection->isSingular() ); dlg.setHasCursor( true ); if ( KFindDialog::Accepted != dlg.exec() ) return; // Save for next time d->findOptions = dlg.options(); d->findStrings = dlg.findHistory(); d->typeValue = dlg.searchType(); d->directionValue = dlg.searchDirection(); // Create the KFind object delete d->find; delete d->replace; d->find = new KFind( dlg.pattern(), dlg.options(), this ); d->replace = 0L; d->searchInSheets.currentSheet = activeSheet(); d->searchInSheets.firstSheet = d->searchInSheets.currentSheet; initFindReplace(); findNext(); } // Initialize a find or replace operation, using d->find or d->replace, // and d->findOptions. void View::initFindReplace() { KFind* findObj = d->find ? d->find : d->replace; Q_ASSERT( findObj ); connect(findObj, TQT_SIGNAL( highlight( const TQString &, int, int ) ), this, TQT_SLOT( slotHighlight( const TQString &, int, int ) ) ); connect(findObj, TQT_SIGNAL( findNext() ), this, TQT_SLOT( findNext() ) ); bool bck = d->findOptions & KFindDialog::FindBackwards; Sheet* currentSheet = d->searchInSheets.currentSheet; TQRect region = ( d->findOptions & KFindDialog::SelectedText ) ? d->selection->selection() : TQRect( 1, 1, currentSheet->maxColumn(), currentSheet->maxRow() ); // All cells int colStart = !bck ? region.left() : region.right(); int colEnd = !bck ? region.right() : region.left(); int rowStart = !bck ? region.top() :region.bottom(); int rowEnd = !bck ? region.bottom() : region.top(); if ( d->findOptions & KFindDialog::FromCursor ) { TQPoint marker( d->selection->marker() ); colStart = marker.x(); rowStart = marker.y(); } d->findLeftColumn = region.left(); d->findRightColumn = region.right(); d->findPos = TQPoint( colStart, rowStart ); d->findEnd = TQPoint( colEnd, rowEnd ); //kdDebug() << k_funcinfo << d->findPos << " to " << d->findEnd << endl; //kdDebug() << k_funcinfo << "leftcol=" << d->findLeftColumn << " rightcol=" << d->findRightColumn << endl; } void View::findNext() { KFind* findObj = d->find ? d->find : d->replace; if ( !findObj ) { find(); return; } KFind::Result res = KFind::NoMatch; Cell* cell = findNextCell(); bool forw = ! ( d->findOptions & KFindDialog::FindBackwards ); while ( res == KFind::NoMatch && cell ) { if ( findObj->needData() ) { if ( d->typeValue == FindOption::Note ) findObj->setData( cell->format()->comment( cell->column(), cell->row() ) ); else findObj->setData( cell->text() ); d->findPos = TQPoint( cell->column(), cell->row() ); //kdDebug() << "setData(cell " << d->findPos << ")" << endl; } // Let KFind inspect the text fragment, and display a dialog if a match is found if ( d->find ) res = d->find->find(); else res = d->replace->replace(); if ( res == KFind::NoMatch ) { // Go to next cell, skipping unwanted cells if ( d->directionValue == FindOption::Row ) { if ( forw ) ++d->findPos.rx(); else --d->findPos.rx(); } else { if ( forw ) ++d->findPos.ry(); else --d->findPos.ry(); } cell = findNextCell(); } } if ( res == KFind::NoMatch ) { //emitUndoRedo(); //removeHighlight(); if ( findObj->shouldRestart() ) { d->findOptions &= ~KFindDialog::FromCursor; findObj->resetCounts(); findNext(); } else { // done, close the 'find next' dialog if ( d->find ) d->find->closeFindNextDialog(); else d->replace->closeReplaceNextDialog(); } } } Cell* View::nextFindValidCell( int col, int row ) { Cell *cell = d->searchInSheets.currentSheet->cellAt( col, row ); if ( cell->isDefault() || cell->isObscured() || cell->isFormula() ) cell = 0L; if ( d->typeValue == FindOption::Note && cell && cell->format()->comment(col, row).isEmpty()) cell = 0L; return cell; } Cell* View::findNextCell() { // getFirstCellRow / getNextCellRight would be faster at doing that, // but it doesn't seem to be easy to combine it with 'start a column d->find.x()'... Sheet* sheet = d->searchInSheets.currentSheet; Cell* cell = 0L; bool forw = ! ( d->findOptions & KFindDialog::FindBackwards ); int col = d->findPos.x(); int row = d->findPos.y(); int maxRow = sheet->maxRow(); //kdDebug() << "findNextCell starting at " << col << "," << row << " forw=" << forw << endl; if ( d->directionValue == FindOption::Row ) { while ( !cell && row != d->findEnd.y() && (forw ? row < maxRow : row >= 0) ) { while ( !cell && (forw ? col <= d->findRightColumn : col >= d->findLeftColumn) ) { cell = nextFindValidCell( col, row ); if ( forw ) ++col; else --col; } if ( cell ) break; // Prepare looking in the next row if ( forw ) { col = d->findLeftColumn; ++row; } else { col = d->findRightColumn; --row; } //kdDebug() << "next row: " << col << "," << row << endl; } } else { while ( !cell && (forw ? col <= d->findRightColumn : col >= d->findLeftColumn) ) { while ( !cell && row != d->findEnd.y() && (forw ? row < maxRow : row >= 0) ) { cell = nextFindValidCell( col, row ); if ( forw ) ++row; else --row; } if ( cell ) break; // Prepare looking in the next col if ( forw ) { row = 0; ++col; } else { col = maxRow; --col; } //kdDebug() << "next row: " << col << "," << row << endl; } } // if ( !cell ) // No more next cell - TODO go to next sheet (if not looking in a selection) // (and make d->findEnd (max,max) in that case...) //kdDebug() << k_funcinfo << " returning " << cell << endl; return cell; } void View::findPrevious() { KFind* findObj = d->find ? d->find : d->replace; if ( !findObj ) { find(); return; } //kdDebug() << "findPrevious" << endl; int opt = d->findOptions; bool forw = ! ( opt & KFindDialog::FindBackwards ); if ( forw ) d->findOptions = ( opt | KFindDialog::FindBackwards ); else d->findOptions = ( opt & ~KFindDialog::FindBackwards ); findNext(); d->findOptions = opt; // restore initial options } void View::replace() { if (!d->activeSheet) return; SearchDlg dlg( this, "Replace", d->findOptions, d->findStrings, d->replaceStrings ); dlg.setHasSelection( !d->selection->isSingular() ); dlg.setHasCursor( true ); if ( KReplaceDialog::Accepted != dlg.exec() ) return; d->findOptions = dlg.options(); d->findStrings = dlg.findHistory(); d->replaceStrings = dlg.replacementHistory(); d->typeValue = dlg.searchType(); delete d->find; delete d->replace; d->find = 0L; // NOTE Stefan: Avoid beginning of line replacements with nothing which // will lead to an infinite loop (Bug #125535). The reason // for this is unclear to me, but who cares and who would // want to do something like this, häh?! if (dlg.pattern() == "^" && dlg.replacement().isEmpty()) return; d->replace = new KReplace( dlg.pattern(), dlg.replacement(), dlg.options() ); d->searchInSheets.currentSheet = activeSheet(); d->searchInSheets.firstSheet = d->searchInSheets.currentSheet; initFindReplace(); connect( d->replace, TQT_SIGNAL( replace( const TQString &, int, int, int ) ), this, TQT_SLOT( slotReplace( const TQString &, int, int, int ) ) ); if ( !doc()->undoLocked() ) { TQRect region( d->findPos, d->findEnd ); //TODO create undo/redo for comment UndoChangeAreaTextCell *undo = new UndoChangeAreaTextCell( doc(), d->searchInSheets.currentSheet, region ); doc()->addCommand( undo ); } findNext(); #if 0 // Refresh the editWidget // TODO - after a replacement only? Cell *cell = activeSheet()->cellAt( canvasWidget()->markerColumn(), canvasWidget()->markerRow() ); if ( cell->text() != 0L ) d->editWidget->setText( cell->text() ); else d->editWidget->setText( "" ); #endif } void View::slotHighlight( const TQString &/*text*/, int /*matchingIndex*/, int /*matchedLength*/ ) { d->selection->initialize( d->findPos ); KDialogBase *baseDialog=0L; if ( d->find ) baseDialog = d->find->findNextDialog(); else baseDialog = d->replace->replaceNextDialog(); kdDebug()<<" baseDialog :"<<baseDialog<<endl; TQRect globalRect( d->findPos, d->findEnd ); globalRect.moveTopLeft( canvasWidget()->mapToGlobal( globalRect.topLeft() ) ); KDialog::avoidArea( baseDialog, TQRect( d->findPos, d->findEnd )); } void View::slotReplace( const TQString &newText, int, int, int ) { // Which cell was this again? Cell *cell = d->searchInSheets.currentSheet->cellAt( d->findPos ); // ...now I remember, update it! cell->setDisplayDirtyFlag(); if ( d->typeValue == FindOption::Value ) cell->setCellText( newText ); else if ( d->typeValue == FindOption::Note ) cell->format()->setComment( newText ); cell->clearDisplayDirtyFlag(); } void View::conditional() { TQRect rect( d->selection->selection() ); if ( util_isRowOrColumnSelected(rect)) { KMessageBox::error( this, i18n("Area is too large.") ); } else { ConditionalDialog dlg( this, "ConditionalDialog", rect); dlg.exec(); } } void View::validity() { TQRect rect( d->selection->selection() ); if (d->selection->isColumnOrRowSelected()) { KMessageBox::error( this, i18n("Area is too large.")); } else { DlgValidity dlg( this,"validity",rect); dlg.exec(); } } void View::insertSeries() { d->canvas->closeEditor(); SeriesDlg dlg( this, "Series", TQPoint( d->canvas->markerColumn(), d->canvas->markerRow() ) ); dlg.exec(); } void View::sort() { if ( d->selection->isSingular() ) { KMessageBox::error( this, i18n("You must select multiple cells.") ); return; } SortDialog dlg( this, "Sort" ); dlg.exec(); } void View::removeHyperlink() { TQPoint marker( d->selection->marker() ); Cell * cell = d->activeSheet->cellAt( marker ); if( !cell ) return; if( cell->link().isEmpty() ) return; LinkCommand* command = new LinkCommand( cell, TQString(), TQString() ); doc()->addCommand( command ); command->execute(); canvasWidget()->setFocus(); d->editWidget->setText( cell->text() ); } void View::insertHyperlink() { if (!activeSheet()) return; d->canvas->closeEditor(); TQPoint marker( d->selection->marker() ); Cell* cell = d->activeSheet->cellAt( marker ); LinkDialog* dlg = new LinkDialog( this ); dlg->setCaption( i18n( "Insert Link" ) ); if( cell ) { dlg->setText( cell->text() ); if( !cell->link().isEmpty() ) { dlg->setCaption( i18n( "Edit Link" ) ); dlg->setLink( cell->link() ); } } if( dlg->exec() == KDialog::Accepted ) { cell = d->activeSheet->nonDefaultCell( marker ); LinkCommand* command = new LinkCommand( cell, dlg->text(), dlg->link() ); doc()->addCommand( command ); command->execute(); //refresh editWidget canvasWidget()->setFocus(); d->editWidget->setText( cell->text() ); } delete dlg; } void View::insertFromDatabase() { #ifndef TQT_NO_SQL d->canvas->closeEditor(); TQRect rect = d->selection->selection(); TQStringList str = TQSqlDatabase::drivers(); if ( str.isEmpty() ) { KMessageBox::error( this, i18n("No database drivers available. To use this feature you need " "to install the necessary TQt 3 database drivers.") ); return; } doc()->doNotPaint( true ); DatabaseDialog dlg(this, rect, "DatabaseDialog"); dlg.exec(); doc()->doNotPaint( false ); #endif } void View::insertFromTextfile() { d->canvas->closeEditor(); //KMessageBox::information( this, "Not implemented yet, work in progress..."); doc()->doNotPaint( true ); CSVDialog dialog( this, "CSVDialog", d->selection->selection(), CSVDialog::File ); if( !dialog.cancelled() ) dialog.exec(); doc()->doNotPaint( false ); } void View::insertFromClipboard() { d->canvas->closeEditor(); doc()->doNotPaint( true ); CSVDialog dialog( this, "CSVDialog", d->selection->selection(), CSVDialog::Clipboard ); if( !dialog.cancelled() ) dialog.exec(); doc()->doNotPaint( false ); } void View::setupPrinter( KPrinter &prt ) { if (!activeSheet()) return; SheetPrint* print = d->activeSheet->print(); //apply page layout parameters KoFormat pageFormat = print->paperFormat(); prt.setPageSize( static_cast<KPrinter::PageSize>( KoPageFormat::printerPageSize( pageFormat ) ) ); if ( print->orientation() == PG_LANDSCAPE || pageFormat == PG_SCREEN ) prt.setOrientation( KPrinter::Landscape ); else prt.setOrientation( KPrinter::Portrait ); prt.setFullPage( true ); //add possibility to select the sheets to print: // kdDebug() << "Adding sheet selection page." << endl; KPSheetSelectPage* sheetpage = new KPSheetSelectPage(); prt.addDialogPage(sheetpage); // kdDebug() << "Iterating through available sheets and initializing list of available sheets." << endl; TQPtrList<Sheet> sheetlist = doc()->map()->sheetList(); Sheet* sheet = sheetlist.last(); while ( sheet ) { kdDebug() << "Adding " << sheet->sheetName() << endl; sheetpage->prependAvailableSheet(sheet->sheetName()); sheet = sheetlist.prev(); } } void View::print( KPrinter &prt ) { if (!activeSheet()) return; //save the current active sheet for later, so we can restore it at the end Sheet* selectedsheet = this->activeSheet(); //print all sheets in the order given by the print dialog (Sheet Selection) TQStringList sheetlist = KPSheetSelectPage::selectedSheets(prt); if (sheetlist.empty()) { kdDebug() << "No sheet for printing selected, printing active sheet" << endl; sheetlist.append(d->activeSheet->sheetName()); } TQPainter painter; painter.begin( &prt ); bool firstpage = true; TQStringList::iterator sheetlistiterator; for (sheetlistiterator = sheetlist.begin(); sheetlistiterator != sheetlist.end(); ++sheetlistiterator) { kdDebug() << " printing sheet " << *sheetlistiterator << endl; Sheet* sheet = doc()->map()->findSheet(*sheetlistiterator); if (sheet == NULL) { kdWarning() << i18n("Sheet %1 could not be found for printing").arg(*sheetlistiterator) << endl; continue; } setActiveSheet(sheet,FALSE); SheetPrint* print = d->activeSheet->print(); if (firstpage) firstpage=false; else { kdDebug() << " inserting new page" << endl; prt.newPage(); } if ( d->canvas->editor() ) { d->canvas->deleteEditor( true ); // save changes } int oldZoom = doc()->zoom(); //Comment from KWord // We don't get valid metrics from the printer - and we want a better resolution // anyway (it's the PS driver that takes care of the printer resolution). //But KSpread uses fixed 300 dpis, so we can use it. TQPaintDeviceMetrics metrics( &prt ); int dpiX = metrics.logicalDpiX(); int dpiY = metrics.logicalDpiY(); doc()->setZoomAndResolution( int( print->zoom() * 100 ), dpiX, dpiY ); //store the current setting in a temporary variable KoOrientation _orient = print->orientation(); //use the current orientation from print dialog if ( prt.orientation() == KPrinter::Landscape ) { print->setPaperOrientation( PG_LANDSCAPE ); } else { print->setPaperOrientation( PG_PORTRAIT ); } bool result = print->print( painter, &prt ); //Restore original orientation print->setPaperOrientation( _orient ); doc()->setZoomAndResolution( oldZoom, KoGlobal::dpiX(), KoGlobal::dpiY() ); doc()->newZoomAndResolution( true, false ); // Repaint at correct zoom doc()->emitBeginOperation( false ); setZoom( oldZoom, false ); doc()->emitEndOperation(); // Nothing to print if( !result ) { if( !prt.previewOnly() ) { KMessageBox::information( 0, i18n("Nothing to print for sheet %1.").arg( d->activeSheet->sheetName()) ); //@todo: make sure we really can comment this out, // what to do with partially broken printouts? // prt.abort(); } } } painter.end(); this->setActiveSheet(selectedsheet); } void View::insertChart( const TQRect& _geometry, KoDocumentEntry& _e ) { if ( !d->activeSheet ) return; // Transform the view coordinates to document coordinates KoRect unzoomedRect = doc()->unzoomRect( _geometry ); unzoomedRect.moveBy( d->canvas->xOffset(), d->canvas->yOffset() ); InsertObjectCommand *cmd = 0; if ( d->selection->isColumnOrRowSelected() ) { KMessageBox::error( this, i18n("Area is too large.")); return; } else cmd = new InsertObjectCommand( unzoomedRect, _e, d->selection->selection(), d->canvas ); doc()->addCommand( cmd ); cmd->execute(); } void View::insertChild( const TQRect& _geometry, KoDocumentEntry& _e ) { if ( !d->activeSheet ) return; // Transform the view coordinates to document coordinates KoRect unzoomedRect = doc()->unzoomRect( _geometry ); unzoomedRect.moveBy( d->canvas->xOffset(), d->canvas->yOffset() ); InsertObjectCommand *cmd = new InsertObjectCommand( unzoomedRect, _e, d->canvas ); doc()->addCommand( cmd ); cmd->execute(); } KoPoint View::markerDocumentPosition() { TQPoint marker=selectionInfo()->marker(); return KoPoint( d->activeSheet->dblColumnPos(marker.x()), d->activeSheet->dblRowPos(marker.y()) ); } void View::insertPicture() { //Note: We don't use the usual insert handler here (which allows the user to drag-select the target area //for the object) because when inserting raster graphics, it is usually desireable to insert at 100% size, //since the graphic won't look right if inserted with an incorrect aspect ratio or if blurred due to the //scaling. If the user wishes to change the size and/or aspect ratio, they can do that afterwards. //This behaviour can be seen in other spreadsheets. //-- Robert Knight 12/02/06 <robertknight@gmail.com> KURL file = KFileDialog::getImageOpenURL( TQString(), d->canvas ); if (file.isEmpty()) return; if ( !d->activeSheet ) return; InsertObjectCommand *cmd = new InsertObjectCommand( KoRect(markerDocumentPosition(),KoSize(0,0)) , file, d->canvas ); doc()->addCommand( cmd ); cmd->execute(); } void View::slotUpdateChildGeometry( EmbeddedKOfficeObject */*_child*/ ) { // ############## // TODO /* if ( _child->sheet() != d->activeSheet ) return; // Find frame for child ChildFrame *f = 0L; TQPtrListIterator<ChildFrame> it( m_lstFrames ); for ( ; it.current() && !f; ++it ) if ( it.current()->child() == _child ) f = it.current(); assert( f != 0L ); // Are we already up to date ? if ( _child->geometry() == f->partGeometry() ) return; // TODO zooming f->setPartGeometry( _child->geometry() ); */ } void View::toggleProtectDoc( bool mode ) { if ( !doc() || !doc()->map() ) return; TQCString passwd; if ( mode ) { int result = KPasswordDialog::getNewPassword( passwd, i18n( "Protect Document" ) ); if ( result != KPasswordDialog::Accepted ) { d->actions->protectDoc->setChecked( false ); return; } TQCString hash( "" ); TQString password( passwd ); if ( password.length() > 0 ) SHA1::getHash( password, hash ); doc()->map()->setProtected( hash ); } else { int result = KPasswordDialog::getPassword( passwd, i18n( "Unprotect Document" ) ); if ( result != KPasswordDialog::Accepted ) { d->actions->protectDoc->setChecked( true ); return; } TQCString hash( "" ); TQString password( passwd ); if ( password.length() > 0 ) SHA1::getHash( password, hash ); if ( !doc()->map()->checkPassword( hash ) ) { KMessageBox::error( 0, i18n( "Password is incorrect." ) ); d->actions->protectDoc->setChecked( true ); return; } doc()->map()->setProtected( TQCString() ); } doc()->setModified( true ); d->adjustWorkbookActions( !mode ); } void View::toggleProtectSheet( bool mode ) { if ( !d->activeSheet ) return; TQCString passwd; if ( mode ) { int result = KPasswordDialog::getNewPassword( passwd, i18n( "Protect Sheet" ) ); if ( result != KPasswordDialog::Accepted ) { d->actions->protectSheet->setChecked( false ); return; } TQCString hash( "" ); TQString password( passwd ); if ( password.length() > 0 ) SHA1::getHash( password, hash ); d->activeSheet->setProtected( hash ); } else { int result = KPasswordDialog::getPassword( passwd, i18n( "Unprotect Sheet" ) ); if ( result != KPasswordDialog::Accepted ) { d->actions->protectSheet->setChecked( true ); return; } TQCString hash( "" ); TQString password( passwd ); if ( password.length() > 0 ) SHA1::getHash( password, hash ); if ( !d->activeSheet->checkPassword( hash ) ) { KMessageBox::error( 0, i18n( "Password is incorrect." ) ); d->actions->protectSheet->setChecked( true ); return; } d->activeSheet->setProtected( TQCString() ); } doc()->setModified( true ); d->adjustActions( !mode ); doc()->emitBeginOperation(); // d->activeSheet->setRegionPaintDirty( TQRect(TQPoint( 0, 0 ), TQPoint( KS_colMax, KS_rowMax ) ) ); refreshView(); updateEditWidget(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::togglePageBorders( bool mode ) { if ( !d->activeSheet ) return; doc()->emitBeginOperation( false ); d->activeSheet->setShowPageBorders( mode ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::viewZoom( const TQString & s ) { int oldZoom = doc()->zoom(); bool ok = false; TQRegExp regexp("(\\d+)"); // "Captured" non-empty sequence of digits regexp.search(s); int newZoom=regexp.cap(1).toInt(&ok); if ( !ok || newZoom < 10 ) //zoom should be valid and >10 newZoom = oldZoom; if ( newZoom != oldZoom ) { d->actions->viewZoom->setZoom( newZoom ); doc()->emitBeginOperation( false ); d->canvas->closeEditor(); setZoom( newZoom, true ); if (activeSheet()) { TQRect r( d->activeSheet->visibleRect( d->canvas ) ); r.setWidth( r.width() + 2 ); doc()->emitEndOperation( r ); } } } void View::setZoom( int zoom, bool /*updateViews*/ ) { kdDebug() << "---------SetZoom: " << zoom << endl; // Set the zoom in KoView (for embedded views) doc()->emitBeginOperation( false ); doc()->setZoomAndResolution( zoom, KoGlobal::dpiX(), KoGlobal::dpiY()); //KoView::setZoom( doc()->zoomedResolutionY() /* KoView only supports one zoom */ ); Q_ASSERT(d->activeSheet); if (d->activeSheet) //this is 0 when viewing a document in konqueror!? (see Q_ASSERT above) d->activeSheet->setRegionPaintDirty(TQRect(TQPoint(0,0), TQPoint(KS_colMax, KS_rowMax))); doc()->refreshInterface(); doc()->emitEndOperation(); } void View::showStatusBar( bool b ) { doc()->setShowStatusBar( b ); refreshView(); } void View::showTabBar( bool b ) { doc()->setShowTabBar( b ); refreshView(); } void View::showFormulaBar( bool b ) { doc()->setShowFormulaBar( b ); refreshView(); } void View::preference() { if ( !d->activeSheet ) return; PreferenceDialog dlg( this, "Preference" ); if ( dlg.exec() ) { doc()->emitBeginOperation( false ); d->activeSheet->refreshPreference(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::addModifyComment() { if ( !d->activeSheet ) return; CommentDialog dlg( this, "comment", TQPoint( d->canvas->markerColumn(), d->canvas->markerRow() ) ); if ( dlg.exec() ) updateEditWidget(); } void View::setSelectionComment( TQString comment ) { if ( d->activeSheet != NULL ) { doc()->emitBeginOperation( false ); d->activeSheet->setSelectionComment( selectionInfo(), comment.stripWhiteSpace() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::editCell() { if ( d->canvas->editor() ) return; d->canvas->createEditor(true); } bool View::showSheet(const TQString& sheetName) { Sheet *t=doc()->map()->findSheet(sheetName); if ( !t ) { kdDebug(36001) << "Unknown sheet " <<sheetName<< endl; return false; } d->canvas->closeEditor(); setActiveSheet( t ); return true; } void View::nextSheet() { Sheet * t = doc()->map()->nextSheet( activeSheet() ); if ( !t ) { kdDebug(36001) << "Unknown sheet " << endl; return; } d->canvas->closeEditor(); setActiveSheet( t ); d->tabBar->setActiveTab( t->sheetName() ); d->tabBar->ensureVisible( t->sheetName() ); } void View::previousSheet() { Sheet * t = doc()->map()->previousSheet( activeSheet() ); if ( !t ) { kdDebug(36001) << "Unknown sheet " << endl; return; } d->canvas->closeEditor(); setActiveSheet( t ); d->tabBar->setActiveTab( t->sheetName() ); d->tabBar->ensureVisible( t->sheetName() ); } void View::firstSheet() { Sheet *t = doc()->map()->firstSheet(); if ( !t ) { kdDebug(36001) << "Unknown sheet " << endl; return; } d->canvas->closeEditor(); setActiveSheet( t ); d->tabBar->setActiveTab( t->sheetName() ); d->tabBar->ensureVisible( t->sheetName() ); } void View::lastSheet() { Sheet *t = doc()->map()->lastSheet( ); if ( !t ) { kdDebug(36001) << "Unknown sheet " << endl; return; } d->canvas->closeEditor(); setActiveSheet( t ); d->tabBar->setActiveTab( t->sheetName() ); d->tabBar->ensureVisible( t->sheetName() ); } void View::keyPressEvent ( TQKeyEvent* _ev ) { // Dont eat accelerators if ( _ev->state() & ( TQt::AltButton | TQt::ControlButton ) ) { if ( _ev->state() & ( TQt::ControlButton ) ) { switch( _ev->key() ) { #ifndef NDEBUG case TQt::Key_V: // Ctrl+Shift+V to show debug (similar to KWord) if ( _ev->state() & TQt::ShiftButton ) d->activeSheet->printDebug(); #endif default: TQWidget::keyPressEvent( _ev ); return; } } TQWidget::keyPressEvent( _ev ); } else TQApplication::sendEvent( d->canvas, _ev ); } KoDocument * View::hitTest( const TQPoint& /*pos*/ ) { // // Code copied from KoView::hitTest // KoViewChild *viewChild; // // TQWMatrix m = matrix(); // m.translate( d->canvas->xOffset() / doc()->zoomedResolutionX(), // d->canvas->yOffset() / doc()->zoomedResolutionY() ); // // KoDocumentChild *docChild = selectedChild(); // if ( docChild ) // { // if ( ( viewChild = child( docChild->document() ) ) ) // { // if ( viewChild->frameRegion( m ).contains( pos ) ) // return 0; // } // else // if ( docChild->frameRegion( m ).contains( pos ) ) // return 0; // } // // docChild = activeChild(); // if ( docChild ) // { // if ( ( viewChild = child( docChild->document() ) ) ) // { // if ( viewChild->frameRegion( m ).contains( pos ) ) // return 0; // } // else // if ( docChild->frameRegion( m ).contains( pos ) ) // return 0; // } // // TQPtrListIterator<KoDocumentChild> it( doc()->children() ); // for (; it.current(); ++it ) // { // // Is the child document on the visible sheet ? // if ( ((EmbeddedKOfficeObject*)it.current())->sheet() == d->activeSheet ) // { // KoDocument *doc = it.current()->hitTest( pos, m ); // if ( doc ) // return doc; // } // } // return doc(); } int View::leftBorder() const { return int( d->canvas->doc()->zoomItX( YBORDER_WIDTH ) ); } int View::rightBorder() const { return d->vertScrollBar->width(); } int View::topBorder() const { return d->toolWidget->height() + int( d->canvas->doc()->zoomItX( Format::globalRowHeight() + 2 ) ); } int View::bottomBorder() const { return d->horzScrollBar->height(); } void View::refreshView() { kdDebug() << "refreshing view" << endl; Sheet * sheet = activeSheet(); if ( !sheet ) return; d->adjustActions( !sheet->isProtected() ); d->actions->viewZoom->setZoom( doc()->zoom() ); bool active = sheet->getShowFormula(); if ( sheet && !sheet->isProtected() ) { d->actions->alignLeft->setEnabled( !active ); d->actions->alignCenter->setEnabled( !active ); d->actions->alignRight->setEnabled( !active ); } d->tabBar->setReadOnly( !doc()->isReadWrite() || doc()->map()->isProtected() ); d->toolWidget->setShown( doc()->showFormulaBar() ); d->editWidget->showEditWidget( doc()->showFormulaBar() ); d->hBorderWidget->setShown( doc()->showColumnHeader() ); d->vBorderWidget->setShown( doc()->showRowHeader() ); d->vertScrollBar->setShown( doc()->showVerticalScrollBar() ); d->horzScrollBar->setShown( doc()->showHorizontalScrollBar() ); d->tabBar->setShown( doc()->showTabBar() ); if ( statusBar() ) statusBar()->setShown( doc()->showStatusBar() ); d->canvas->updatePosWidget(); d->hBorderWidget->setMinimumHeight( doc()->zoomItY( KoGlobal::defaultFont().pointSizeFloat() + 5 ) ); d->vBorderWidget->setMinimumWidth( doc()->zoomItX( YBORDER_WIDTH ) ); Sheet::LayoutDirection sheetDir = sheet->layoutDirection(); bool interfaceIsRTL = TQApplication::reverseLayout(); kdDebug()<<" sheetDir == Sheet::LeftToRight :"<<( sheetDir == Sheet::LeftToRight )<<endl; if ((sheetDir == Sheet::LeftToRight && !interfaceIsRTL) || (sheetDir == Sheet::RightToLeft && interfaceIsRTL)) { d->formulaBarLayout->setDirection( TQBoxLayout::LeftToRight ); d->viewLayout->setOrigin( TQGridLayout::TopLeft ); d->tabScrollBarLayout->setDirection( TQBoxLayout::LeftToRight ); d->tabBar->setReverseLayout( interfaceIsRTL ); } else { d->formulaBarLayout->setDirection( TQBoxLayout::RightToLeft ); d->viewLayout->setOrigin( TQGridLayout::TopRight ); d->tabScrollBarLayout->setDirection( TQBoxLayout::RightToLeft ); d->tabBar->setReverseLayout( !interfaceIsRTL ); } } void View::resizeEvent( TQResizeEvent * ) { } void View::popupChildMenu( KoChild* child, const TQPoint& /*global_pos*/ ) { if ( !child ) return; delete d->popupChild; // d->popupChildObject = static_cast<EmbeddedKOfficeObject*>(child); // // d->popupChild = new TQPopupMenu( this ); // // d->popupChild->insertItem( i18n("Delete Embedded Document"), this, TQT_SLOT( slotPopupDeleteChild() ) ); // // d->popupChild->popup( global_pos ); } void View::slotPopupDeleteChild() { // if ( !d->popupChildObject || !d->popupChildObject->sheet() ) // return; //Removed popup warning dialog because // a) It is annoying from a user's persepective // b) The behaviour should be consistant with other KOffice apps /*int ret = KMessageBox::warningContinueCancel(this,i18n("You are about to remove this embedded document.\nDo you want to continue?"),i18n("Delete Embedded Document"),KGuiItem(i18n("&Delete"),"editdelete")); if ( ret == KMessageBox::Continue ) { }*/ // doc()->emitBeginOperation(false); // d->popupChildObject->sheet()->deleteChild( d->popupChildObject ); // d->popupChildObject = 0; // doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::popupColumnMenu( const TQPoint & _point ) { assert( d->activeSheet ); if ( !koDocument()->isReadWrite() ) return; delete d->popupColumn ; d->popupColumn = new TQPopupMenu( this ); bool isProtected = d->activeSheet->isProtected(); if ( !isProtected ) { d->actions->cellLayout->plug( d->popupColumn ); d->popupColumn->insertSeparator(); d->actions->cut->plug( d->popupColumn ); } d->actions->copy->plug( d->popupColumn ); if ( !isProtected ) { d->actions->paste->plug( d->popupColumn ); d->actions->specialPaste->plug( d->popupColumn ); d->actions->insertCellCopy->plug( d->popupColumn ); d->popupColumn->insertSeparator(); d->actions->defaultFormat->plug( d->popupColumn ); // If there is no selection if (!d->selection->isColumnOrRowSelected()) { d->actions->areaName->plug( d->popupColumn ); } d->actions->resizeColumn->plug( d->popupColumn ); d->popupColumn->insertItem( i18n("Adjust Column"), this, TQT_SLOT(slotPopupAdjustColumn() ) ); d->popupColumn->insertSeparator(); d->actions->insertColumn->plug( d->popupColumn ); d->actions->deleteColumn->plug( d->popupColumn ); d->actions->hideColumn->plug( d->popupColumn ); d->actions->showSelColumns->setEnabled(false); ColumnFormat* format; //kdDebug(36001) << "Column: L: " << rect.left() << endl; Region::ConstIterator endOfList = d->selection->constEnd(); for (Region::ConstIterator it = d->selection->constBegin(); it != endOfList; ++it) { TQRect range = (*it)->rect().normalize(); int col; for (col = range.left(); col < range.right(); ++col) { format = activeSheet()->columnFormat(col); if ( format->isHide() ) { d->actions->showSelColumns->setEnabled( true ); d->actions->showSelColumns->plug( d->popupColumn ); break; } } if (range.left() > 1 && col == range.right()) { bool allHidden = true; for (col = 1; col < range.left(); ++col) { format = activeSheet()->columnFormat(col); allHidden &= format->isHide(); } if (allHidden) { d->actions->showSelColumns->setEnabled( true ); d->actions->showSelColumns->plug( d->popupColumn ); break; } } else { break; } } } TQT_BASE_OBJECT_NAME::connect( d->popupColumn, TQT_SIGNAL(activated( int ) ), this, TQT_SLOT( slotActivateTool( int ) ) ); d->popupColumn->popup( _point ); } void View::slotPopupAdjustColumn() { if ( !d->activeSheet ) return; d->activeSheet->adjustColumn(*selectionInfo()); } void View::popupRowMenu( const TQPoint & _point ) { assert( d->activeSheet ); if ( !koDocument()->isReadWrite() ) return; delete d->popupRow ; d->popupRow= new TQPopupMenu(); bool isProtected = d->activeSheet->isProtected(); if ( !isProtected ) { d->actions->cellLayout->plug( d->popupRow ); d->popupRow->insertSeparator(); d->actions->cut->plug( d->popupRow ); } d->actions->copy->plug( d->popupRow ); if ( !isProtected ) { d->actions->paste->plug( d->popupRow ); d->actions->specialPaste->plug( d->popupRow ); d->actions->insertCellCopy->plug( d->popupRow ); d->popupRow->insertSeparator(); d->actions->defaultFormat->plug( d->popupRow ); // If there is no selection if (!d->selection->isColumnOrRowSelected()) { d->actions->areaName->plug(d->popupRow); } d->actions->resizeRow->plug( d->popupRow ); d->popupRow->insertItem( i18n("Adjust Row"), this, TQT_SLOT( slotPopupAdjustRow() ) ); d->popupRow->insertSeparator(); d->actions->insertRow->plug( d->popupRow ); d->actions->deleteRow->plug( d->popupRow ); d->actions->hideRow->plug( d->popupRow ); d->actions->showSelColumns->setEnabled(false); RowFormat* format; Region::ConstIterator endOfList = d->selection->constEnd(); for (Region::ConstIterator it = d->selection->constBegin(); it != endOfList; ++it) { TQRect range = (*it)->rect().normalize(); int row; for (row = range.top(); row < range.bottom(); ++row) { format = activeSheet()->rowFormat(row); if ( format->isHide() ) { d->actions->showSelRows->setEnabled( true ); d->actions->showSelRows->plug( d->popupRow ); break; } } if (range.top() > 1 && row == range.bottom()) { bool allHidden = true; for (row = 1; row < range.top(); ++row) { format = activeSheet()->rowFormat(row); allHidden &= format->isHide(); } if (allHidden) { d->actions->showSelRows->setEnabled( true ); d->actions->showSelRows->plug( d->popupRow ); break; } } else { break; } } } TQT_BASE_OBJECT_NAME::connect( d->popupRow, TQT_SIGNAL( activated( int ) ), this, TQT_SLOT( slotActivateTool( int ) ) ); d->popupRow->popup( _point ); } void View::slotPopupAdjustRow() { if ( !d->activeSheet ) return; d->activeSheet->adjustRow(*selectionInfo()); } void View::slotListChoosePopupMenu( ) { if ( !koDocument()->isReadWrite() ) return; assert( d->activeSheet ); delete d->popupListChoose; d->popupListChoose = new TQPopupMenu(); int id = 0; TQRect selection( d->selection->selection() ); Cell * cell = d->activeSheet->cellAt( d->canvas->markerColumn(), d->canvas->markerRow() ); TQString tmp = cell->text(); TQStringList itemList; for ( int col = selection.left(); col <= selection.right(); ++col ) { Cell * c = d->activeSheet->getFirstCellColumn( col ); while ( c ) { if ( !c->isPartOfMerged() && !( col == d->canvas->markerColumn() && c->row() == d->canvas->markerRow()) ) { if ( c->value().isString() && c->text() != tmp && !c->text().isEmpty() ) { if ( itemList.findIndex( c->text() ) == -1 ) itemList.append(c->text()); } } c = d->activeSheet->getNextCellDown( col, c->row() ); } } /* TODO: remove this later: for( ;c; c = c->nextCell() ) { int col = c->column(); if ( selection.left() <= col && selection.right() >= col &&!c->isPartOfMerged()&& !(col==d->canvas->markerColumn()&& c->row()==d->canvas->markerRow())) { if (c->isString() && c->text()!=tmp && !c->text().isEmpty()) { if (itemList.findIndex(c->text())==-1) itemList.append(c->text()); } } } */ for ( TQStringList::Iterator it = itemList.begin(); it != itemList.end();++it ) d->popupListChoose->insertItem( (*it), id++ ); if ( id == 0 ) return; RowFormat * rl = d->activeSheet->rowFormat( d->canvas->markerRow()); double tx = d->activeSheet->dblColumnPos( d->canvas->markerColumn(), d->canvas ); double ty = d->activeSheet->dblRowPos(d->canvas->markerRow(), d->canvas ); double h = rl->dblHeight( d->canvas ); if ( cell->extraYCells() ) h = cell->extraHeight(); ty += h; if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) { tx = canvasWidget()->width() - tx; } TQPoint p( (int)tx, (int)ty ); TQPoint p2 = d->canvas->mapToGlobal( p ); if ( d->activeSheet->layoutDirection()==Sheet::RightToLeft ) { p2.setX( p2.x() - d->popupListChoose->sizeHint().width() + 1 ); } d->popupListChoose->popup( p2 ); TQT_BASE_OBJECT_NAME::connect( d->popupListChoose, TQT_SIGNAL( activated( int ) ), this, TQT_SLOT( slotItemSelected( int ) ) ); } void View::slotItemSelected( int id ) { TQString tmp = d->popupListChoose->text( id ); int x = d->canvas->markerColumn(); int y = d->canvas->markerRow(); Cell * cell = d->activeSheet->nonDefaultCell( x, y ); if ( tmp == cell->text() ) return; doc()->emitBeginOperation( false ); if ( !doc()->undoLocked() ) { UndoSetText* undo = new UndoSetText( doc(), d->activeSheet, cell->text(), x, y, cell->formatType() ); doc()->addCommand( undo ); } cell->setCellText( tmp ); d->editWidget->setText( tmp ); doc()->emitEndOperation( TQRect( x, y, 1, 1 ) ); } void View::openPopupMenu( const TQPoint & _point ) { assert( d->activeSheet ); delete d->popupMenu; if ( !koDocument()->isReadWrite() ) return; d->popupMenu = new TQPopupMenu(); EmbeddedObject *obj; if ( d->canvas->isObjectSelected() && ( obj = d->canvas->getObject( d->canvas->mapFromGlobal( _point ), d->activeSheet ) ) && obj->isSelected() ) { d->actions->deleteCell->plug( d->popupMenu ); d->popupMenu->insertSeparator(); d->actions->cut->plug( d->popupMenu ); d->actions->copy->plug( d->popupMenu ); d->actions->paste->plug( d->popupMenu ); d->popupMenu->popup( _point ); d->popupMenu->insertSeparator(); d->actions->actionExtraProperties->plug( d->popupMenu ); return; } Cell * cell = d->activeSheet->cellAt( d->canvas->markerColumn(), d->canvas->markerRow() ); bool isProtected = d->activeSheet->isProtected(); if ( !cell->isDefault() && cell->format()->notProtected( d->canvas->markerColumn(), d->canvas->markerRow() ) && d->selection->isSingular() ) isProtected = false; if ( !isProtected ) { d->actions->cellLayout->plug( d->popupMenu ); d->popupMenu->insertSeparator(); d->actions->cut->plug( d->popupMenu ); } d->actions->copy->plug( d->popupMenu ); if ( !isProtected ) d->actions->paste->plug( d->popupMenu ); if ( !isProtected ) { d->actions->specialPaste->plug( d->popupMenu ); d->actions->insertCellCopy->plug( d->popupMenu ); d->popupMenu->insertSeparator(); d->actions->deleteCell->plug( d->popupMenu ); d->actions->adjust->plug( d->popupMenu ); d->actions->defaultFormat->plug( d->popupMenu ); // If there is no selection if (!d->selection->isColumnOrRowSelected()) { d->actions->areaName->plug( d->popupMenu ); d->popupMenu->insertSeparator(); d->actions->insertCell->plug( d->popupMenu ); d->actions->removeCell->plug( d->popupMenu ); } d->popupMenu->insertSeparator(); d->actions->addModifyComment->plug( d->popupMenu ); if ( !cell->format()->comment(d->canvas->markerColumn(), d->canvas->markerRow()).isEmpty() ) { d->actions->removeComment->plug( d->popupMenu ); } if (activeSheet()->testListChoose(selectionInfo())) { d->popupMenu->insertSeparator(); d->popupMenu->insertItem( i18n("Selection List..."), this, TQT_SLOT( slotListChoosePopupMenu() ) ); } } // Remove informations about the last tools we offered d->toolList.clear(); d->toolList.setAutoDelete( true ); if ( !isProtected && !activeSheet()->getWordSpelling( selectionInfo() ).isEmpty() ) { d->popupMenuFirstToolId = 10; int i = 0; TQValueList<KDataToolInfo> tools = KDataToolInfo::query( TQSTRING_OBJECT_NAME_STRING, "text/plain", doc()->instance() ); if ( tools.count() > 0 ) { d->popupMenu->insertSeparator(); TQValueList<KDataToolInfo>::Iterator entry = tools.begin(); for( ; entry != tools.end(); ++entry ) { TQStringList lst = (*entry).userCommands(); TQStringList::ConstIterator it = lst.begin(); // ### Torben: Insert pixmaps here, too for (; it != lst.end(); ++it ) d->popupMenu->insertItem( *it, d->popupMenuFirstToolId + i++ ); lst = (*entry).commands(); it = lst.begin(); for (; it != lst.end(); ++it ) { Private::ToolEntry *t = new Private::ToolEntry; t->command = *it; t->info = *entry; d->toolList.append( t ); } } TQT_BASE_OBJECT_NAME::connect( d->popupMenu, TQT_SIGNAL( activated( int ) ), this, TQT_SLOT( slotActivateTool( int ) ) ); } } d->popupMenu->popup( _point ); } void View::slotActivateTool( int _id ) { if (!activeSheet()) return; // Is it the id of a tool in the latest popupmenu ? if ( _id < d->popupMenuFirstToolId ) return; Private::ToolEntry* entry = d->toolList.at( _id - d->popupMenuFirstToolId ); KDataTool* tool = entry->info.createTool(); if ( !tool ) { kdDebug(36001) << "Could not create Tool" << endl; return; } TQString text = activeSheet()->getWordSpelling( selectionInfo() ); if ( tool->run( entry->command, &text, TQSTRING_OBJECT_NAME_STRING, "text/plain") ) { doc()->emitBeginOperation(false); activeSheet()->setWordSpelling( selectionInfo(), text); Cell *cell = d->activeSheet->cellAt( d->canvas->markerColumn(), d->canvas->markerRow() ); d->editWidget->setText( cell->text() ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::deleteSelection() { if (!activeSheet()) return; if ( canvasWidget()->isObjectSelected() ) { deleteSelectedObjects(); return; } doc()->emitBeginOperation( false ); d->activeSheet->deleteSelection( selectionInfo() ); calcStatusBarOp(); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::deleteSelectedObjects() { KMacroCommand * macroCommand = 0L; TQPtrListIterator<EmbeddedObject> it( doc()->embeddedObjects() ); for ( ; it.current() ; ++it ) { if ( it.current()->sheet() == canvasWidget()->activeSheet() && it.current()->isSelected() ) { // d->activeSheet->setRegionPaintDirty( it. if( !macroCommand ) macroCommand = new KMacroCommand( i18n( "Remove Object" ) ); RemoveObjectCommand *cmd = new RemoveObjectCommand( it.current() ); macroCommand->addCommand( cmd ); } } if ( macroCommand ) { doc()->addCommand( macroCommand ); canvasWidget()->setMouseSelectedObject( false ); macroCommand->execute(); } } void View::adjust() { if ( !d->activeSheet ) return; d->activeSheet->adjustArea(*selectionInfo()); } void View::clearTextSelection() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->clearTextSelection( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::clearCommentSelection() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->setSelectionRemoveComment( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::clearValiditySelection() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->clearValiditySelection( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::clearConditionalSelection() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->clearConditionalSelection( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::fillRight() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->fillSelection( selectionInfo(), Sheet::Right ); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::fillLeft() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->fillSelection( selectionInfo(), Sheet::Left ); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::fillUp() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->fillSelection( selectionInfo(), Sheet::Up ); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::fillDown() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->fillSelection( selectionInfo(), Sheet::Down ); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::defaultSelection() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); d->activeSheet->defaultSelection( selectionInfo() ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::slotInsert() { TQRect r( d->selection->selection() ); InsertDialog dlg( this, "InsertDialog", r, InsertDialog::Insert ); dlg.exec(); } void View::slotRemove() { TQRect r( d->selection->selection() ); InsertDialog dlg( this, "Remove", r, InsertDialog::Remove ); dlg.exec(); } void View::slotInsertCellCopy() { if ( !d->activeSheet ) return; if ( !d->activeSheet->testAreaPasteInsert() ) { doc()->emitBeginOperation( false ); d->activeSheet->paste( d->selection->lastRange(), true, Paste::Normal, Paste::OverWrite, true ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } else { PasteInsertDialog dlg( this, "Remove", d->selection->selection() ); dlg.exec(); } if ( d->activeSheet->getAutoCalc() ) { doc()->emitBeginOperation( false ); d->activeSheet->recalc(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } updateEditWidget(); } void View::setAreaName() { AreaDialog dlg( this, "Area Name",TQPoint(d->canvas->markerColumn(), d->canvas->markerRow()) ); dlg.exec(); } void View::showAreaName() { reference dlg( this, "Show Area" ); dlg.exec(); } void View::resizeRow() { if (!activeSheet()) return; if ( d->selection->isColumnSelected() ) KMessageBox::error( this, i18n("Area is too large.")); else { ResizeRow dlg( this ); dlg.exec(); } } void View::resizeColumn() { if (!activeSheet()) return; if ( d->selection->isRowSelected() ) KMessageBox::error( this, i18n( "Area is too large." ) ); else { ResizeColumn dlg( this ); dlg.exec(); } } void View::equalizeRow() { if (!activeSheet()) return; if ( d->selection->isColumnSelected() ) KMessageBox::error( this, i18n( "Area is too large." ) ); else { doc()->emitBeginOperation( false ); canvasWidget()->equalizeRow(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::equalizeColumn() { if (!activeSheet()) return; if ( d->selection->isRowSelected() ) KMessageBox::error( this, i18n( "Area is too large." ) ); else { doc()->emitBeginOperation( false ); canvasWidget()->equalizeColumn(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::layoutDlg() { if (!activeSheet()) return; CellFormatDialog dlg( this, d->activeSheet ); } void View::extraProperties() { if (!activeSheet()) return; //d->canvas->setToolEditMode( TEM_MOUSE ); d->m_propertyEditor = new PropertyEditor( this, "KPrPropertyEditor", d->activeSheet, doc() ); d->m_propertyEditor->setCaption( i18n( "Properties" ) ); connect( d->m_propertyEditor, TQT_SIGNAL( propertiesOk() ), this, TQT_SLOT( propertiesOk() ) ); d->m_propertyEditor->exec(); disconnect( d->m_propertyEditor, TQT_SIGNAL( propertiesOk() ), this, TQT_SLOT( propertiesOk() ) ); delete d->m_propertyEditor; d->m_propertyEditor = 0; } void View::propertiesOk() { KCommand *cmd = d->m_propertyEditor->getCommand(); if ( cmd ) { cmd->execute(); doc()->addCommand( cmd ); } } void View::styleDialog() { StyleDlg dlg( this, doc()->styleManager() ); dlg.exec(); d->actions->selectStyle->setItems( doc()->styleManager()->styleNames() ); if ( d->activeSheet ) { d->activeSheet->setLayoutDirtyFlag(); d->activeSheet->setRegionPaintDirty( d->activeSheet->visibleRect( d->canvas ) ); } if ( d->canvas ) d->canvas->repaint(); } void View::paperLayoutDlg() { if ( d->canvas->editor() ) { d->canvas->deleteEditor( true ); // save changes } SheetPrint* print = d->activeSheet->print(); KoPageLayout pl; pl.format = print->paperFormat(); pl.orientation = print->orientation(); pl.ptWidth = MM_TO_POINT( print->paperWidth() ); pl.ptHeight = MM_TO_POINT( print->paperHeight() ); pl.ptLeft = MM_TO_POINT( print->leftBorder() ); pl.ptRight = MM_TO_POINT( print->rightBorder() ); pl.ptTop = MM_TO_POINT( print->topBorder() ); pl.ptBottom = MM_TO_POINT( print->bottomBorder() ); KoHeadFoot hf; hf.headLeft = print->localizeHeadFootLine( print->headLeft() ); hf.headRight = print->localizeHeadFootLine( print->headRight() ); hf.headMid = print->localizeHeadFootLine( print->headMid() ); hf.footLeft = print->localizeHeadFootLine( print->footLeft() ); hf.footRight = print->localizeHeadFootLine( print->footRight() ); hf.footMid = print->localizeHeadFootLine( print->footMid() ); KoUnit::Unit unit = doc()->unit(); PaperLayout * dlg = new PaperLayout( this, "PageLayout", pl, hf, FORMAT_AND_BORDERS | HEADER_AND_FOOTER, unit, d->activeSheet, this ); dlg->show(); // dlg destroys itself } void View::definePrintRange() { d->activeSheet->print()->definePrintRange( selectionInfo() ); } void View::resetPrintRange() { d->activeSheet->print()->resetPrintRange(); } void View::wrapText( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); d->activeSheet->setSelectionMultiRow( selectionInfo(), b ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::alignLeft( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlign( selectionInfo(), Format::Undefined ); else d->activeSheet->setSelectionAlign( selectionInfo(), Format::Left ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::alignRight( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlign( selectionInfo(), Format::Undefined ); else d->activeSheet->setSelectionAlign( selectionInfo(), Format::Right ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::alignCenter( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlign( selectionInfo(), Format::Undefined ); else d->activeSheet->setSelectionAlign( selectionInfo(), Format::Center ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::alignTop( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlignY( selectionInfo(), Format::UndefinedY ); else d->activeSheet->setSelectionAlignY( selectionInfo(), Format::Top ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::alignBottom( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlignY( selectionInfo(), Format::UndefinedY ); else d->activeSheet->setSelectionAlignY( selectionInfo(), Format::Bottom ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::alignMiddle( bool b ) { if ( d->toolbarLock ) return; if ( d->activeSheet != 0L ) { doc()->emitBeginOperation( false ); if ( !b ) d->activeSheet->setSelectionAlignY( selectionInfo(), Format::UndefinedY ); else d->activeSheet->setSelectionAlignY( selectionInfo(), Format::Middle ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::moneyFormat(bool b) { if ( d->toolbarLock ) return; doc()->emitBeginOperation( false ); if ( d->activeSheet != 0L ) d->activeSheet->setSelectionMoneyFormat( selectionInfo(), b ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::createStyleFromCell() { if ( !d->activeSheet ) return; TQPoint p( d->selection->selection().topLeft() ); Cell * cell = d->activeSheet->nonDefaultCell( p.x(), p.y() ); bool ok = false; TQString styleName( "" ); while( true ) { styleName = KInputDialog::getText( i18n( "Create Style From Cell" ), i18n( "Enter name:" ), styleName, &ok, this ); if ( !ok ) // User pushed an OK button. return; styleName = styleName.stripWhiteSpace(); if ( styleName.length() < 1 ) { KNotifyClient::beep(); KMessageBox::sorry( this, i18n( "The style name cannot be empty." ) ); continue; } if ( doc()->styleManager()->style( styleName ) != 0 ) { KNotifyClient::beep(); KMessageBox::sorry( this, i18n( "A style with this name already exists." ) ); continue; } break; } CustomStyle * style = new CustomStyle( cell->format()->style(), styleName ); doc()->styleManager()->m_styles[ styleName ] = style; cell->format()->setStyle( style ); TQStringList lst( d->actions->selectStyle->items() ); lst.push_back( styleName ); d->actions->selectStyle->setItems( lst ); } void View::styleSelected( const TQString & style ) { if (d->activeSheet ) { Style * s = doc()->styleManager()->style( style ); if ( s ) { doc()->emitBeginOperation(false); d->activeSheet->setSelectionStyle( selectionInfo(), s ); markSelectionAsDirty(); doc()->emitEndOperation(); } } } void View::precisionPlus() { setSelectionPrecision( 1 ); } void View::precisionMinus() { setSelectionPrecision( -1 ); } void View::setSelectionPrecision( int delta ) { if ( d->activeSheet != NULL ) { doc()->emitBeginOperation( false ); d->activeSheet->setSelectionPrecision( selectionInfo(), delta ); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::percent( bool b ) { if ( d->toolbarLock ) return; doc()->emitBeginOperation( false ); if ( d->activeSheet != 0L ) d->activeSheet->setSelectionPercent( selectionInfo() ,b ); updateEditWidget(); markSelectionAsDirty(); doc()->emitEndOperation(); } void View::insertObject() { if (!activeSheet()) return; doc()->emitBeginOperation( false ); KoDocumentEntry e = d->actions->insertPart->documentEntry();//KoPartSelectDia::selectPart( d->canvas ); if ( e.isEmpty() ) { doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); return; } //Don't start handles more than once delete d->insertHandler; d->insertHandler = new InsertPartHandler( this, d->canvas, e ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::insertChart() { if (!activeSheet()) return; if ( d->selection->isColumnOrRowSelected() ) { KMessageBox::error( this, i18n("Area too large.")); return; } TQValueList<KoDocumentEntry> vec = KoDocumentEntry::query( true, "'KOfficeChart' in ServiceTypes" ); if ( vec.isEmpty() ) { KMessageBox::error( this, i18n("No charting component registered.") ); return; } //Don't start handles more than once delete d->insertHandler; doc()->emitBeginOperation( false ); d->insertHandler = new InsertChartHandler( this, d->canvas, vec[0] ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } /* // TODO Use KoView setScaling/xScaling/yScaling instead void View::zoomMinus() { if ( m_fZoom <= 0.25 ) return; m_fZoom -= 0.25; if ( d->activeSheet != 0L ) d->activeSheet->setLayoutDirtyFlag(); d->canvas->repaint(); d->vBorderWidget->repaint(); d->hBorderWidget->repaint(); } void View::zoomPlus() { if ( m_fZoom >= 3 ) return; m_fZoom += 0.25; if ( d->activeSheet != 0L ) d->activeSheet->setLayoutDirtyFlag(); d->canvas->repaint(); d->vBorderWidget->repaint(); d->hBorderWidget->repaint(); } */ void View::removeSheet() { if ( doc()->map()->count() <= 1 || ( doc()->map()->visibleSheets().count() <= 1 ) ) { KNotifyClient::beep(); KMessageBox::sorry( this, i18n("You cannot delete the only sheet."), i18n("Remove Sheet") ); // FIXME bad english? no english! return; } KNotifyClient::beep(); int ret = KMessageBox::warningContinueCancel( this, i18n( "You are about to remove the active sheet.\nDo you want to continue?" ), i18n( "Remove Sheet" ),KGuiItem(i18n("&Delete"),"editdelete") ); if ( ret == KMessageBox::Continue ) { doc()->emitBeginOperation( false ); if ( d->canvas->editor() ) { d->canvas->deleteEditor( false ); } doc()->setModified( true ); Sheet * tbl = activeSheet(); KCommand* command = new RemoveSheetCommand( tbl ); doc()->addCommand( command ); command->execute(); #if 0 UndoRemoveSheet * undo = new UndoRemoveSheet( doc(), tbl ); doc()->addCommand( undo ); tbl->doc()->map()->takeSheet( tbl ); doc()->takeSheet( tbl ); #endif doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::slotRename() { Sheet * sheet = activeSheet(); if( sheet->isProtected() ) { KMessageBox::error( 0, i18n ( "You cannot change a protected sheet." ) ); return; } bool ok; TQString activeName = sheet->sheetName(); TQString newName = KInputDialog::getText( i18n("Rename Sheet"),i18n("Enter name:"), activeName, &ok, this ); if( !ok ) return; while (!util_validateSheetName(newName)) { KNotifyClient::beep(); KMessageBox::information( this, i18n("Sheet name contains illegal characters. Only numbers and letters are allowed."), i18n("Change Sheet Name") ); newName = newName.simplifyWhiteSpace(); int n = newName.find('-'); if ( n > -1 ) newName[n] = '_'; n = newName.find('!'); if ( n > -1 ) newName[n] = '_'; n = newName.find('$'); if ( n > -1 ) newName[n] = '_'; newName = KInputDialog::getText( i18n("Rename Sheet"),i18n("Enter name:"), newName, &ok, this ); if ( !ok ) return; } if ( (newName.stripWhiteSpace()).isEmpty() ) // Sheet name is empty. { KNotifyClient::beep(); KMessageBox::information( this, i18n("Sheet name cannot be empty."), i18n("Change Sheet Name") ); // Recursion slotRename(); } else if ( newName != activeName ) // Sheet name changed. { // Is the name already used if ( doc()->map()->findSheet( newName ) ) { KNotifyClient::beep(); KMessageBox::information( this, i18n("This name is already used."), i18n("Change Sheet Name") ); // Recursion slotRename(); return; } KCommand* command = new RenameSheetCommand( sheet, newName ); doc()->addCommand( command ); command->execute(); //sheet->setSheetName( newName ); doc()->emitBeginOperation(false); updateEditWidget(); doc()->setModified( true ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } } void View::setText (const TQString & _text, bool array) { if ( d->activeSheet == 0L ) return; if (array) { // array version d->activeSheet->setArrayFormula (d->selection, _text); } else { // non-array version int x = d->canvas->markerColumn(); int y = d->canvas->markerRow(); d->activeSheet->setText( y, x, _text ); Cell * cell = d->activeSheet->cellAt( x, y ); if ( cell->value().isString() && !_text.isEmpty() && !_text.at(0).isDigit() && !cell->isFormula() ) doc()->addStringCompletion( _text ); } } //------------------------------------------------ // // Document signals // //------------------------------------------------ void View::slotAddSheet( Sheet *_sheet ) { addSheet( _sheet ); } void View::slotRefreshView() { refreshView(); d->canvas->repaint(); d->vBorderWidget->repaint(); d->hBorderWidget->repaint(); } void View::slotUpdateView( Sheet *_sheet ) { // Do we display this sheet ? if ( ( !activeSheet() ) || ( _sheet != d->activeSheet ) ) return; d->activeSheet->setRegionPaintDirty( d->activeSheet->visibleRect( d->canvas ) ); doc()->emitEndOperation(); } void View::slotUpdateView( Sheet * _sheet, const Region& region ) { // tqDebug("void View::slotUpdateView( Sheet *_sheet, const TQRect& %i %i|%i %i )\n",_rect.left(),_rect.top(),_rect.right(),_rect.bottom()); // Do we display this sheet ? if ( _sheet != d->activeSheet ) return; // doc()->emitBeginOperation( false ); d->activeSheet->setRegionPaintDirty( region ); doc()->emitEndOperation( region ); } void View::slotUpdateView( EmbeddedObject *obj ) { d->canvas->repaintObject( obj ); } void View::slotUpdateHBorder( Sheet * _sheet ) { // kdDebug(36001)<<"void View::slotUpdateHBorder( Sheet *_sheet )\n"; // Do we display this sheet ? if ( _sheet != d->activeSheet ) return; doc()->emitBeginOperation(false); d->hBorderWidget->update(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::slotUpdateVBorder( Sheet *_sheet ) { // kdDebug("void View::slotUpdateVBorder( Sheet *_sheet )\n"; // Do we display this sheet ? if ( _sheet != d->activeSheet ) return; doc()->emitBeginOperation( false ); d->vBorderWidget->update(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::slotChangeSelection(const KSpread::Region& changedRegion) { // kdDebug() << *selectionInfo() << endl; if (!changedRegion.isValid()) { return; } doc()->emitBeginOperation( false ); bool colSelected = d->selection->isColumnSelected(); bool rowSelected = d->selection->isRowSelected(); if (d->activeSheet && !d->activeSheet->isProtected()) { // Activate or deactivate some actions. d->actions->insertRow->setEnabled( !colSelected ); d->actions->deleteRow->setEnabled( !colSelected ); d->actions->resizeRow->setEnabled( !colSelected ); d->actions->equalizeRow->setEnabled( !colSelected ); d->actions->hideRow->setEnabled( !colSelected ); d->actions->validity->setEnabled( !colSelected && !rowSelected); d->actions->conditional->setEnabled( !colSelected && !rowSelected); d->actions->insertColumn->setEnabled( !rowSelected ); d->actions->deleteColumn->setEnabled( !rowSelected ); d->actions->resizeColumn->setEnabled( !rowSelected ); d->actions->equalizeColumn->setEnabled( !rowSelected ); d->actions->hideColumn->setEnabled( !rowSelected ); d->actions->textToColumns->setEnabled( !rowSelected ); bool simpleSelection = d->selection->isSingular() || colSelected || rowSelected; d->actions->autoFormat->setEnabled( !simpleSelection ); d->actions->sort->setEnabled( !simpleSelection ); d->actions->mergeCell->setEnabled( !simpleSelection ); d->actions->mergeCellHorizontal->setEnabled( !simpleSelection ); d->actions->mergeCellVertical->setEnabled( !simpleSelection ); d->actions->fillRight->setEnabled( !simpleSelection ); d->actions->fillUp->setEnabled( !simpleSelection ); d->actions->fillDown->setEnabled( !simpleSelection ); d->actions->fillLeft->setEnabled( !simpleSelection ); d->actions->sortDec->setEnabled( !simpleSelection ); d->actions->sortInc->setEnabled( !simpleSelection); d->actions->createStyle->setEnabled( simpleSelection ); // just from one cell bool contiguousSelection = d->selection->isContiguous(); d->actions->subTotals->setEnabled(contiguousSelection); } d->actions->selectStyle->setCurrentItem( -1 ); // delayed recalculation of the operation shown in the status bar d->statusBarOpTimer.start(250, true); // Send some event around. This is read for example // by the calculator plugin. // SelectionChanged ev(*selectionInfo(), activeSheet()->name()); // TQApplication::sendEvent( this, &ev ); d->canvas->setSelectionChangePaintDirty( d->activeSheet, changedRegion ); d->vBorderWidget->update(); d->hBorderWidget->update(); if (colSelected || rowSelected) { doc()->emitEndOperation(/* *selectionInfo() */); return; } d->canvas->validateSelection(); //Don't scroll to the marker if there is an active embedded object, since this may cause //the canvas to scroll so that the object isn't in the visible area. //There is still the problem of the object no longer being visible immediately after deactivating the child //as the sheet jumps back to the marker though. if (!activeChild()) d->canvas->scrollToCell(selectionInfo()->marker()); // Perhaps the user is entering a value in the cell. // In this case we may not touch the EditWidget if ( !d->canvas->editor() && !d->canvas->chooseMode() ) { updateEditWidgetOnPress(); } d->canvas->updatePosWidget(); doc()->emitEndOperation(/* *selectionInfo() */); } void View::slotChangeChoice(const KSpread::Region& changedRegion) { if (!changedRegion.isValid()) { return; } doc()->emitBeginOperation( false ); d->canvas->updateEditor(); d->canvas->setSelectionChangePaintDirty( d->activeSheet, changedRegion ); doc()->emitEndOperation( *choice() ); kdDebug() << "Choice: " << *choice() << endl; } void View::slotScrollChoice( const KSpread::Region& changedRegion ) { if ( !changedRegion.isValid() ) return; d->canvas->scrollToCell( choice()->marker() ); } void View::calcStatusBarOp() { Sheet * sheet = activeSheet(); ValueCalc* calc = d->doc->calc(); Value val; TQRect tmpRect(d->selection->selection()); MethodOfCalc tmpMethod = doc()->getTypeOfCalc(); if ( tmpMethod != NoneCalc ) { Value range = sheet->valueRange (tmpRect.left(), tmpRect.top(), tmpRect.right(), tmpRect.bottom()); switch (tmpMethod) { case SumOfNumber: val = calc->sum (range); break; case Average: val = calc->avg (range); break; case Min: val = calc->min (range); break; case Max: val = calc->max (range); break; case CountA: val = Value (calc->count (range)); break; case Count: val = Value (calc->count (range, false)); case NoneCalc: break; default: break; } } TQString res = d->doc->converter()->asString (val).asString (); TQString tmp; switch(tmpMethod ) { case SumOfNumber: tmp = i18n("Sum: ") + res; break; case Average: tmp = i18n("Average: ") + res; break; case Min: tmp = i18n("Min: ") + res; break; case Max: tmp = i18n("Max: ") + res; break; case Count: tmp = i18n("Count: ") + res; break; case CountA: tmp = i18n("CountA: ") + res; break; case NoneCalc: tmp = ""; break; } //doc()->emitBeginOperation(); if ( d->calcLabel ) d->calcLabel->setText(TQString(" ") + tmp + ' '); //doc()->emitEndOperation(); } void View::statusBarClicked(int _id) { if ( !koDocument()->isReadWrite() || !factory() ) return; if ( _id == 0 ) //menu calc { TQPoint mousepos = TQCursor::pos(); ((TQPopupMenu*)factory()->container( "calc_popup" , this ) )->popup( mousepos ); } } void View::menuCalc( bool ) { doc()->emitBeginOperation(false); if ( d->actions->calcMin->isChecked() ) { doc()->setTypeOfCalc( Min ); } else if ( d->actions->calcMax->isChecked() ) { doc()->setTypeOfCalc( Max ); } else if ( d->actions->calcCount->isChecked() ) { doc()->setTypeOfCalc( Count ); } else if ( d->actions->calcAverage->isChecked() ) { doc()->setTypeOfCalc( Average ); } else if ( d->actions->calcSum->isChecked() ) { doc()->setTypeOfCalc( SumOfNumber ); } else if ( d->actions->calcCountA->isChecked() ) { doc()->setTypeOfCalc( CountA ); } else if ( d->actions->calcNone->isChecked() ) doc()->setTypeOfCalc( NoneCalc ); calcStatusBarOp(); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } TQWMatrix View::matrix() const { TQWMatrix m; m.scale( d->doc->zoomedResolutionX(), d->doc->zoomedResolutionY() ); m.translate( - d->canvas->xOffset(), - d->canvas->yOffset() ); return m; } void View::transformPart() { Q_ASSERT( selectedChild() ); if ( d->transformToolBox.isNull() ) { d->transformToolBox = new KoTransformToolBox( selectedChild(), topLevelWidget() ); d->transformToolBox->show(); d->transformToolBox->setDocumentChild( selectedChild() ); } else { d->transformToolBox->show(); d->transformToolBox->raise(); } } void View::slotChildSelected( KoDocumentChild* /*ch*/ ) { // if ( d->activeSheet && !d->activeSheet->isProtected() ) // { // d->actions->transform->setEnabled( true ); // // if ( !d->transformToolBox.isNull() ) // { // d->transformToolBox->setEnabled( true ); // d->transformToolBox->setDocumentChild( ch ); // } // } doc()->emitBeginOperation( false ); d->activeSheet->setRegionPaintDirty(TQRect(TQPoint(0,0), TQPoint(KS_colMax, KS_rowMax))); doc()->emitEndOperation(); paintUpdates(); } void View::slotChildUnselected( KoDocumentChild* ) { // if ( d->activeSheet && !d->activeSheet->isProtected() ) // { // d->actions->transform->setEnabled( false ); // // if ( !d->transformToolBox.isNull() ) // { // d->transformToolBox->setEnabled( false ); // } // deleteEditor( true ); // } doc()->emitBeginOperation( false ); d->activeSheet->setRegionPaintDirty(TQRect(TQPoint(0,0), TQPoint(KS_colMax, KS_rowMax))); doc()->emitEndOperation(); paintUpdates(); } void View::deleteEditor( bool saveChanges ) { doc()->emitBeginOperation( false ); d->canvas->deleteEditor( saveChanges ); markSelectionAsDirty(); doc()->emitEndOperation(); } DCOPObject * View::dcopObject() { if ( !d->dcop ) d->dcop = new ViewIface( this ); return d->dcop; } TQWidget * View::canvas() const { return canvasWidget(); } int View::canvasXOffset() const { if (!d->activeSheet) return 0; double zoomedResX = d->activeSheet->doc()->zoomedResolutionX(); return int( canvasWidget()->xOffset() * zoomedResX ); } int View::canvasYOffset() const { if (!d->activeSheet) return 0; double zoomedResY = d->activeSheet->doc()->zoomedResolutionY(); return int( canvasWidget()->yOffset() * zoomedResY ); } void View::guiActivateEvent( KParts::GUIActivateEvent *ev ) { if ( d->activeSheet ) { doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); if ( ev->activated() ) { if ( d->calcLabel ) calcStatusBarOp(); } else { /*if (d->calcLabel) { disconnect(d->calcLabel,TQT_SIGNAL(pressed( int )),this,TQT_SLOT(statusBarClicked(int))); }*/ } } KoView::guiActivateEvent( ev ); } void View::popupTabBarMenu( const TQPoint & _point ) { if ( !koDocument()->isReadWrite() || !factory() ) return; if ( d->tabBar ) { bool state = ( doc()->map()->visibleSheets().count() > 1 ); if ( d->activeSheet && d->activeSheet->isProtected() ) { d->actions->removeSheet->setEnabled( false ); d->actions->hideSheet->setEnabled( false ); d->actions->showSheet->setEnabled( false ); } else { d->actions->removeSheet->setEnabled( state); d->actions->hideSheet->setEnabled( state ); d->actions->showSheet->setEnabled( doc()->map()->hiddenSheets().count()>0 ); } if ( !doc() || !doc()->map() || doc()->map()->isProtected() ) { d->actions->insertSheet->setEnabled( false ); d->actions->renameSheet->setEnabled( false ); d->actions->showSheet->setEnabled( false ); d->actions->hideSheet->setEnabled( false ); d->actions->removeSheet->setEnabled( false ); } static_cast<TQPopupMenu*>(factory()->container("menupage_popup",this))->popup(_point); } } void View::updateBorderButton() { // doc()->emitBeginOperation( false ); if ( d->activeSheet ) d->actions->showPageBorders->setChecked( d->activeSheet->isShowPageBorders() ); // doc()->emitEndOperation(); } void View::removeSheet( Sheet *_t ) { doc()->emitBeginOperation(false); TQString m_tablName=_t->sheetName(); d->tabBar->removeTab( m_tablName ); setActiveSheet( doc()->map()->findSheet( doc()->map()->visibleSheets().first() )); bool state = doc()->map()->visibleSheets().count() > 1; d->actions->removeSheet->setEnabled( state ); d->actions->hideSheet->setEnabled( state ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::insertSheet( Sheet* sheet ) { doc()->emitBeginOperation( false ); TQString tabName = sheet->sheetName(); if ( !sheet->isHidden() ) { d->tabBar->addTab( tabName ); } bool state = ( doc()->map()->visibleSheets().count() > 1 ); d->actions->removeSheet->setEnabled( state ); d->actions->hideSheet->setEnabled( state ); doc()->emitEndOperation( sheet->visibleRect( d->canvas ) ); } TQColor View::borderColor() const { return d->actions->borderColor->color(); } void View::updateShowSheetMenu() { doc()->emitBeginOperation( false ); if ( d->activeSheet->isProtected() ) d->actions->showSheet->setEnabled( false ); else d->actions->showSheet->setEnabled( doc()->map()->hiddenSheets().count() > 0 ); doc()->emitEndOperation( d->activeSheet->visibleRect( d->canvas ) ); } void View::closeEditor() { if ( d->activeSheet ) { // #45822 doc()->emitBeginOperation( false ); d->canvas->closeEditor(); markSelectionAsDirty(); doc()->emitEndOperation(); } } void View::markSelectionAsDirty() { if (!d->activeSheet) return; d->activeSheet->setRegionPaintDirty( *selectionInfo() ); } void View::paintUpdates() { /* don't do any begin/end operation here -- this is what is called at an endOperation */ d->canvas->paintUpdates(); } void View::commandExecuted() { updateEditWidget(); calcStatusBarOp(); } void View::initialiseMarkerFromSheet( Sheet *_sheet, const TQPoint &point ) { d->savedMarkers.replace( _sheet, point); } TQPoint View::markerFromSheet( Sheet* sheet ) const { TQMapIterator<Sheet*, TQPoint> it = d->savedMarkers.find(sheet); TQPoint newMarker = (it == d->savedMarkers.end()) ? TQPoint(1,1) : *it; return newMarker; } KoPoint View::offsetFromSheet( Sheet* sheet ) const { TQMapIterator<Sheet*, KoPoint> it = d->savedOffsets.find(sheet); KoPoint offset = (it == d->savedOffsets.end()) ? KoPoint() : *it; return offset; } void View::saveCurrentSheetSelection() { /* save the current selection on this sheet */ if (d->activeSheet != NULL) { d->savedAnchors.replace(d->activeSheet, d->selection->anchor()); kdDebug() << " Current scrollbar vert value: " << d->canvas->vertScrollBar()->value() << endl; kdDebug() << "Saving marker pos: " << d->selection->marker() << endl; d->savedMarkers.replace(d->activeSheet, d->selection->marker()); d->savedOffsets.replace(d->activeSheet, KoPoint(d->canvas->xOffset(), d->canvas->yOffset())); } } void View::handleDamages( const TQValueList<Damage*>& damages ) { TQValueList<Damage*>::ConstIterator it; for( it = damages.begin(); it != damages.end(); ++it ) { Damage* damage = *it; if( !damage ) continue; if( damage->type() == Damage::Cell ) { CellDamage* cd = static_cast<CellDamage*>( damage ); Cell* damagedCell = cd->cell(); Sheet* damagedSheet = damagedCell->sheet(); TQRect drect( damagedCell->column(), damagedCell->row(), 1, 1 ); damagedSheet->setRegionPaintDirty( drect ); paintUpdates(); } if( damage->type() == Damage::Sheet ) { SheetDamage* sd = static_cast<SheetDamage*>( damage ); Sheet* damagedSheet = sd->sheet(); if( sd->action() == SheetDamage::PropertiesChanged ) { CellBinding * b = 0; for ( b = damagedSheet->firstCellBinding(); b != 0; b = damagedSheet->nextCellBinding() ) b->cellChanged( 0 ); d->activeSheet->setRegionPaintDirty( TQRect(TQPoint(0,0), TQPoint(KS_colMax, KS_rowMax))); paintUpdates(); refreshView(); } } } } void View::runInternalTests() { // run various tests, only for developers KSpread::TestRunner* runner = new KSpread::TestRunner(); runner->exec(); delete runner; } void View::runInspector() { // useful to inspect objects if(!d->activeSheet) return; Cell * cell = d->activeSheet->cellAt( d->selection->marker() ); KSpread::Inspector* ins = new KSpread::Inspector( cell ); ins->exec(); delete ins; } TQColor View::highlightColor() { return TQApplication::palette().active().highlight().light( 175 ); } } // namespace KSpread #include "kspread_view.moc"