You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7546 lines
225 KiB
7546 lines
225 KiB
/* 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 tqchildren
|
|
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 tqlayout 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").tqarg(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
|
|
// tqrepaint, 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->tqsetSizePolicy( TQSizePolicy::Expanding, TQSizePolicy::Minimum );
|
|
d->vBorderWidget->tqsetSizePolicy( 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)
|
|
{
|
|
qWarning("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->tqrepaint();
|
|
d->hBorderWidget->tqrepaint();
|
|
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->tqrepaint();
|
|
d->hBorderWidget->tqrepaint();
|
|
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::tqclipboard()->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->tqencodedData( 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::tqclipboard()->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 tqlayout 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").tqarg(*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.").tqarg(
|
|
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& _tqgeometry, KoDocumentEntry& _e )
|
|
{
|
|
if ( !d->activeSheet )
|
|
return;
|
|
|
|
// Transform the view coordinates to document coordinates
|
|
KoRect unzoomedRect = doc()->unzoomRect( _tqgeometry );
|
|
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& _tqgeometry, KoDocumentEntry& _e )
|
|
{
|
|
if ( !d->activeSheet )
|
|
return;
|
|
|
|
// Transform the view coordinates to document coordinates
|
|
KoRect unzoomedRect = doc()->unzoomRect( _tqgeometry );
|
|
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->tqgeometry() == f->partGeometry() )
|
|
return;
|
|
|
|
// TODO zooming
|
|
f->setPartGeometry( _child->tqgeometry() );
|
|
*/
|
|
}
|
|
|
|
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()->tqchildren() );
|
|
// 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->tqsizeHint().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->tqrepaint();
|
|
}
|
|
|
|
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->tqrepaint();
|
|
d->vBorderWidget->tqrepaint();
|
|
d->hBorderWidget->tqrepaint();
|
|
}
|
|
|
|
void View::zoomPlus()
|
|
{
|
|
if ( m_fZoom >= 3 )
|
|
return;
|
|
|
|
m_fZoom += 0.25;
|
|
|
|
if ( d->activeSheet != 0L )
|
|
d->activeSheet->setLayoutDirtyFlag();
|
|
|
|
d->canvas->tqrepaint();
|
|
d->vBorderWidget->tqrepaint();
|
|
d->hBorderWidget->tqrepaint();
|
|
}
|
|
*/
|
|
|
|
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->tqrepaint();
|
|
d->vBorderWidget->tqrepaint();
|
|
d->hBorderWidget->tqrepaint();
|
|
}
|
|
|
|
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 )
|
|
{
|
|
// qDebug("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(), tqtopLevelWidget() );
|
|
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::tqpalette().active().highlight().light( 175 );
|
|
}
|
|
|
|
} // namespace KSpread
|
|
|
|
#include "kspread_view.moc"
|