Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
21 : #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
22 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
23 : #include <com/sun/star/accessibility/XAccessible.hpp>
24 : #include <com/sun/star/beans/XPropertySet.hpp>
25 : #include <com/sun/star/frame/Desktop.hpp>
26 : #include <com/sun/star/frame/XFramesSupplier.hpp>
27 : #include <com/sun/star/container/XChild.hpp>
28 :
29 : #include <comphelper/processfactory.hxx>
30 : #include <comphelper/storagehelper.hxx>
31 : #include <comphelper/string.hxx>
32 : #include <sfx2/app.hxx>
33 : #include <sfx2/dispatch.hxx>
34 : #include <sfx2/docfile.hxx>
35 : #include <sfx2/docfilt.hxx>
36 : #include <sfx2/docinsert.hxx>
37 : #include <sfx2/filedlghelper.hxx>
38 : #include <sfx2/msg.hxx>
39 : #include <sfx2/objface.hxx>
40 : #include <sfx2/printer.hxx>
41 : #include <sfx2/request.hxx>
42 : #include <svl/eitem.hxx>
43 : #include <svl/intitem.hxx>
44 : #include <svl/itemset.hxx>
45 : #include <svl/poolitem.hxx>
46 : #include <svl/ptitem.hxx>
47 : #include <svl/stritem.hxx>
48 : #include <svtools/transfer.hxx>
49 : #include <svtools/miscopt.hxx>
50 : #include <svl/undo.hxx>
51 : #include <svl/whiter.hxx>
52 : #include <svx/dialogs.hrc>
53 : #include <svx/zoomslideritem.hxx>
54 : #include <editeng/editeng.hxx>
55 : #include <svx/svxdlg.hxx>
56 : #include <sfx2/zoomitem.hxx>
57 : #include <vcl/decoview.hxx>
58 : #include <vcl/menu.hxx>
59 : #include <vcl/msgbox.hxx>
60 : #include <vcl/wrkwin.hxx>
61 : #include <fstream>
62 :
63 : #include "unomodel.hxx"
64 : #include "view.hxx"
65 : #include "config.hxx"
66 : #include "dialog.hxx"
67 : #include "document.hxx"
68 : #include "starmath.hrc"
69 : #include "toolbox.hxx"
70 : #include "mathmlimport.hxx"
71 : #include "cursor.hxx"
72 : #include "accessibility.hxx"
73 : #include "ElementsDockingWindow.hxx"
74 :
75 : #define MINZOOM 25
76 : #define MAXZOOM 800
77 :
78 : // space around the edit window, in pixels
79 : #define CMD_BOX_PADDING 10
80 :
81 : #define SmViewShell
82 : #include "smslots.hxx"
83 :
84 : using namespace com::sun::star;
85 : using namespace com::sun::star::accessibility;
86 : using namespace com::sun::star::uno;
87 :
88 : //////////////////////////////////////////////////////////////////////
89 :
90 21 : SmGraphicWindow::SmGraphicWindow(SmViewShell* pShell):
91 21 : ScrollableWindow(&pShell->GetViewFrame()->GetWindow(), 0),
92 : pAccessible(0),
93 : pViewShell(pShell),
94 21 : nZoom(100)
95 : {
96 : // docking windows are usually hidden (often already done in the
97 : // resource) and will be shown by the sfx framework.
98 21 : Hide();
99 :
100 21 : const Fraction aFraction (1,1);
101 21 : SetMapMode( MapMode(MAP_100TH_MM, Point(), aFraction, aFraction));
102 :
103 21 : ApplyColorConfigValues( SM_MOD()->GetColorConfig() );
104 :
105 21 : SetTotalSize();
106 :
107 21 : SetHelpId(HID_SMA_WIN_DOCUMENT);
108 21 : SetUniqueId(HID_SMA_WIN_DOCUMENT);
109 :
110 21 : ShowLine(false);
111 21 : CaretBlinkInit();
112 21 : }
113 :
114 34 : SmGraphicWindow::~SmGraphicWindow()
115 : {
116 17 : if (pAccessible)
117 3 : pAccessible->ClearWin(); // make Accessible defunctional
118 : // Note: memory for pAccessible will be freed when the reference
119 : // xAccessible is released.
120 17 : CaretBlinkStop();
121 17 : }
122 :
123 59 : void SmGraphicWindow::StateChanged( StateChangedType eType )
124 : {
125 59 : if ( eType == STATE_CHANGE_INITSHOW )
126 17 : Show();
127 59 : ScrollableWindow::StateChanged( eType );
128 59 : }
129 :
130 :
131 21 : void SmGraphicWindow::ApplyColorConfigValues( const svtools::ColorConfig &rColorCfg )
132 : {
133 : // Note: SetTextColor not necessary since the nodes that
134 : // get painted have the color information.
135 : #if OSL_DEBUG_LEVEL > 1
136 : // ColorData nVal = rColorCfg.GetColorValue(svtools::DOCCOLOR).nColor;
137 : #endif
138 21 : SetBackground( Color( (ColorData) rColorCfg.GetColorValue(svtools::DOCCOLOR).nColor ) );
139 21 : Invalidate();
140 21 : }
141 :
142 :
143 0 : void SmGraphicWindow::DataChanged( const DataChangedEvent& rEvt )
144 : {
145 0 : ApplyColorConfigValues( SM_MOD()->GetColorConfig() );
146 :
147 0 : ScrollableWindow::DataChanged( rEvt );
148 0 : }
149 :
150 :
151 0 : void SmGraphicWindow::MouseButtonDown(const MouseEvent& rMEvt)
152 : {
153 0 : ScrollableWindow::MouseButtonDown(rMEvt);
154 :
155 0 : GrabFocus();
156 :
157 : //
158 : // set formula-cursor and selection of edit window according to the
159 : // position clicked at
160 : //
161 : OSL_ENSURE(rMEvt.GetClicks() > 0, "Sm : 0 clicks");
162 0 : if ( rMEvt.IsLeft() )
163 : {
164 : // get click position relativ to formula
165 0 : Point aPos (PixelToLogic(rMEvt.GetPosPixel())
166 0 : - GetFormulaDrawPos());
167 :
168 0 : const SmNode *pTree = pViewShell->GetDoc()->GetFormulaTree();
169 0 : if (!pTree)
170 0 : return;
171 :
172 0 : if (IsInlineEditEnabled()) {
173 0 : pViewShell->GetDoc()->GetCursor().MoveTo(this, aPos, !rMEvt.IsShift());
174 0 : return;
175 : }
176 0 : const SmNode *pNode = 0;
177 : // if it was clicked inside the formula then get the appropriate node
178 0 : if (pTree->OrientedDist(aPos) <= 0)
179 0 : pNode = pTree->FindRectClosestTo(aPos);
180 :
181 0 : if (pNode)
182 0 : { SmEditWindow *pEdit = pViewShell->GetEditWindow();
183 0 : if (!pEdit)
184 0 : return;
185 0 : const SmToken aToken (pNode->GetToken());
186 :
187 : // set selection to the beginning of the token
188 0 : ESelection aSel (aToken.nRow - 1, aToken.nCol - 1);
189 :
190 0 : if (rMEvt.GetClicks() != 1 || aToken.eType == TPLACE)
191 0 : aSel.nEndPos = aSel.nEndPos + sal::static_int_cast< sal_uInt16 >(aToken.aText.getLength());
192 :
193 0 : pEdit->SetSelection(aSel);
194 0 : SetCursor(pNode);
195 :
196 : // allow for immediate editing and
197 : //! implicitly synchronize the cursor position mark in this window
198 0 : pEdit->GrabFocus();
199 : }
200 : }
201 : }
202 :
203 0 : void SmGraphicWindow::MouseMove(const MouseEvent &rMEvt)
204 : {
205 0 : ScrollableWindow::MouseMove(rMEvt);
206 :
207 0 : if (rMEvt.IsLeft() && IsInlineEditEnabled())
208 : {
209 0 : Point aPos(PixelToLogic(rMEvt.GetPosPixel()) - GetFormulaDrawPos());
210 0 : pViewShell->GetDoc()->GetCursor().MoveTo(this, aPos, false);
211 :
212 0 : CaretBlinkStop();
213 0 : SetIsCursorVisible(true);
214 0 : CaretBlinkStart();
215 0 : RepaintViewShellDoc();
216 : }
217 0 : }
218 :
219 112 : bool SmGraphicWindow::IsInlineEditEnabled() const
220 : {
221 112 : return pViewShell->IsInlineEditEnabled();
222 : }
223 :
224 1 : void SmGraphicWindow::GetFocus()
225 : {
226 1 : if (!IsInlineEditEnabled())
227 2 : return;
228 0 : if (pViewShell->GetEditWindow())
229 0 : pViewShell->GetEditWindow()->Flush();
230 : //Let view shell know what insertions should be done in visual editor
231 0 : pViewShell->SetInsertIntoEditWindow(false);
232 0 : SetIsCursorVisible(true);
233 0 : ShowLine(true);
234 0 : CaretBlinkStart();
235 0 : RepaintViewShellDoc();
236 : }
237 :
238 1 : void SmGraphicWindow::LoseFocus()
239 : {
240 1 : ScrollableWindow::LoseFocus();
241 1 : if (xAccessible.is())
242 : {
243 2 : uno::Any aOldValue, aNewValue;
244 1 : aOldValue <<= AccessibleStateType::FOCUSED;
245 : // aNewValue remains empty
246 : pAccessible->LaunchEvent( AccessibleEventId::STATE_CHANGED,
247 2 : aOldValue, aNewValue );
248 : }
249 1 : if (!IsInlineEditEnabled())
250 2 : return;
251 0 : SetIsCursorVisible(false);
252 0 : ShowLine(false);
253 0 : CaretBlinkStop();
254 0 : RepaintViewShellDoc();
255 : }
256 :
257 0 : void SmGraphicWindow::RepaintViewShellDoc()
258 : {
259 0 : SmDocShell &rDoc = *pViewShell->GetDoc();
260 0 : rDoc.Repaint();
261 0 : }
262 :
263 0 : IMPL_LINK_NOARG(SmGraphicWindow, CaretBlinkTimerHdl)
264 : {
265 0 : if (IsCursorVisible())
266 0 : SetIsCursorVisible(false);
267 : else
268 0 : SetIsCursorVisible(true);
269 :
270 0 : RepaintViewShellDoc();
271 :
272 0 : return 0;
273 : }
274 :
275 21 : void SmGraphicWindow::CaretBlinkInit()
276 : {
277 21 : aCaretBlinkTimer.SetTimeoutHdl(LINK(this, SmGraphicWindow, CaretBlinkTimerHdl));
278 21 : aCaretBlinkTimer.SetTimeout( ScrollableWindow::GetSettings().GetStyleSettings().GetCursorBlinkTime() );
279 21 : }
280 :
281 0 : void SmGraphicWindow::CaretBlinkStart()
282 : {
283 0 : if (!IsInlineEditEnabled())
284 0 : return;
285 0 : if ( aCaretBlinkTimer.GetTimeout() != STYLE_CURSOR_NOBLINKTIME )
286 0 : aCaretBlinkTimer.Start();
287 : }
288 :
289 17 : void SmGraphicWindow::CaretBlinkStop()
290 : {
291 17 : if (!IsInlineEditEnabled())
292 34 : return;
293 0 : aCaretBlinkTimer.Stop();
294 : }
295 :
296 24 : void SmGraphicWindow::ShowCursor(bool bShow)
297 : // shows or hides the formula-cursor depending on 'bShow' is true or not
298 : {
299 24 : if (IsInlineEditEnabled())
300 24 : return;
301 :
302 24 : bool bInvert = bShow != IsCursorVisible();
303 :
304 24 : if (bInvert)
305 7 : InvertTracking(aCursorRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW);
306 :
307 24 : SetIsCursorVisible(bShow);
308 : }
309 :
310 21 : void SmGraphicWindow::ShowLine(bool bShow)
311 : {
312 21 : if (!IsInlineEditEnabled())
313 42 : return;
314 :
315 0 : bIsLineVisible = bShow;
316 : }
317 :
318 7 : void SmGraphicWindow::SetCursor(const SmNode *pNode)
319 : {
320 7 : if (IsInlineEditEnabled())
321 7 : return;
322 :
323 7 : const SmNode *pTree = pViewShell->GetDoc()->GetFormulaTree();
324 :
325 : // get appropriate rectangle
326 7 : Point aOffset (pNode->GetTopLeft() - pTree->GetTopLeft()),
327 7 : aTLPos (GetFormulaDrawPos() + aOffset);
328 7 : aTLPos.X() -= pNode->GetItalicLeftSpace();
329 7 : Size aSize (pNode->GetItalicSize());
330 :
331 7 : SetCursor(Rectangle(aTLPos, aSize));
332 : }
333 :
334 7 : void SmGraphicWindow::SetCursor(const Rectangle &rRect)
335 : // sets cursor to new position (rectangle) 'rRect'.
336 : // The old cursor will be removed, and the new one will be shown if
337 : // that is activated in the ConfigItem
338 : {
339 7 : if (IsInlineEditEnabled())
340 7 : return;
341 :
342 7 : SmModule *pp = SM_MOD();
343 :
344 7 : if (IsCursorVisible())
345 0 : ShowCursor(false); // clean up remainings of old cursor
346 7 : aCursorRect = rRect;
347 7 : if (pp->GetConfig()->IsShowFormulaCursor())
348 7 : ShowCursor(true); // draw new cursor
349 : }
350 :
351 17 : const SmNode * SmGraphicWindow::SetCursorPos(sal_uInt16 nRow, sal_uInt16 nCol)
352 : // looks for a VISIBLE node in the formula tree with it's token at
353 : // (or around) the position 'nRow', 'nCol' in the edit window
354 : // (row and column numbering starts with 1 there!).
355 : // If there is such a node the formula-cursor is set to cover that nodes
356 : // rectangle. If not the formula-cursor will be hidden.
357 : // In any case the search result is being returned.
358 : {
359 17 : if (IsInlineEditEnabled())
360 0 : return NULL;
361 :
362 : // find visible node with token at nRow, nCol
363 17 : const SmNode *pTree = pViewShell->GetDoc()->GetFormulaTree(),
364 17 : *pNode = 0;
365 17 : if (pTree)
366 17 : pNode = pTree->FindTokenAt(nRow, nCol);
367 :
368 17 : if (pNode)
369 7 : SetCursor(pNode);
370 : else
371 10 : ShowCursor(false);
372 :
373 17 : return pNode;
374 : }
375 :
376 17 : void SmGraphicWindow::Paint(const Rectangle&)
377 : {
378 : OSL_ENSURE(pViewShell, "Sm : NULL pointer");
379 :
380 17 : SmDocShell &rDoc = *pViewShell->GetDoc();
381 17 : Point aPoint;
382 :
383 17 : rDoc.DrawFormula(*this, aPoint, true); //! modifies aPoint to be the topleft
384 : //! corner of the formula
385 17 : SetFormulaDrawPos(aPoint);
386 17 : if(IsInlineEditEnabled())
387 : {
388 : //Draw cursor if any...
389 0 : if(pViewShell->GetDoc()->HasCursor() && IsLineVisible())
390 0 : pViewShell->GetDoc()->GetCursor().Draw(*this, aPoint, IsCursorVisible());
391 : }
392 : else
393 : {
394 17 : SetIsCursorVisible(false); // (old) cursor must be drawn again
395 :
396 17 : const SmEditWindow *pEdit = pViewShell->GetEditWindow();
397 17 : if (pEdit)
398 : { // get new position for formula-cursor (for possible altered formula)
399 : sal_Int32 nRow;
400 : sal_uInt16 nCol;
401 17 : SmGetLeftSelectionPart(pEdit->GetSelection(), nRow, nCol);
402 17 : nRow++;
403 17 : nCol++;
404 17 : const SmNode *pFound = SetCursorPos(static_cast<sal_uInt16>(nRow), nCol);
405 :
406 17 : SmModule *pp = SM_MOD();
407 17 : if (pFound && pp->GetConfig()->IsShowFormulaCursor())
408 7 : ShowCursor(true);
409 : }
410 : }
411 17 : }
412 :
413 :
414 32 : void SmGraphicWindow::SetTotalSize ()
415 : {
416 32 : SmDocShell &rDoc = *pViewShell->GetDoc();
417 32 : const Size aTmp( PixelToLogic( LogicToPixel( rDoc.GetSize() )));
418 32 : if ( aTmp != ScrollableWindow::GetTotalSize() )
419 31 : ScrollableWindow::SetTotalSize( aTmp );
420 32 : }
421 :
422 0 : void SmGraphicWindow::KeyInput(const KeyEvent& rKEvt)
423 : {
424 0 : if (!IsInlineEditEnabled()) {
425 0 : if (! (GetView() && GetView()->KeyInput(rKEvt)) )
426 0 : ScrollableWindow::KeyInput(rKEvt);
427 0 : return;
428 : }
429 :
430 0 : SmCursor& rCursor = pViewShell->GetDoc()->GetCursor();
431 0 : KeyFuncType eFunc = rKEvt.GetKeyCode().GetFunction();
432 0 : if (eFunc == KEYFUNC_COPY)
433 0 : rCursor.Copy();
434 0 : else if (eFunc == KEYFUNC_CUT)
435 0 : rCursor.Cut();
436 0 : else if (eFunc == KEYFUNC_PASTE)
437 0 : rCursor.Paste();
438 : else {
439 0 : sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
440 0 : switch(nCode)
441 : {
442 : case KEY_LEFT:
443 : {
444 0 : rCursor.Move(this, MoveLeft, !rKEvt.GetKeyCode().IsShift());
445 0 : }break;
446 : case KEY_RIGHT:
447 : {
448 0 : rCursor.Move(this, MoveRight, !rKEvt.GetKeyCode().IsShift());
449 0 : }break;
450 : case KEY_UP:
451 : {
452 0 : rCursor.Move(this, MoveUp, !rKEvt.GetKeyCode().IsShift());
453 0 : }break;
454 : case KEY_DOWN:
455 : {
456 0 : rCursor.Move(this, MoveDown, !rKEvt.GetKeyCode().IsShift());
457 0 : }break;
458 : case KEY_RETURN:
459 : {
460 0 : if(!rKEvt.GetKeyCode().IsShift())
461 0 : rCursor.InsertRow();
462 : #ifdef DEBUG_ENABLE_DUMPASDOT
463 : else {
464 : SmNode *pTree = (SmNode*)pViewShell->GetDoc()->GetFormulaTree();
465 : std::fstream file("/tmp/smath-dump.gv", std::fstream::out);
466 : OUString label(pViewShell->GetDoc()->GetText());
467 : pTree->DumpAsDot(file, &label);
468 : file.close();
469 : }
470 : #endif /* DEBUG_ENABLE_DUMPASDOT */
471 0 : }break;
472 : case KEY_DELETE:
473 : {
474 0 : if(!rCursor.HasSelection()){
475 0 : rCursor.Move(this, nCode == KEY_DELETE ? MoveRight : MoveLeft, false);
476 0 : if(rCursor.HasComplexSelection()) break;
477 : }
478 0 : rCursor.Delete();
479 0 : }break;
480 : case KEY_BACKSPACE:
481 : {
482 0 : rCursor.DeletePrev(this);
483 0 : }break;
484 : case KEY_ADD:
485 0 : rCursor.InsertElement(PlusElement);
486 0 : break;
487 : case KEY_SUBTRACT:
488 0 : if(rKEvt.GetKeyCode().IsShift())
489 0 : rCursor.InsertSubSup(RSUB);
490 : else
491 0 : rCursor.InsertElement(MinusElement);
492 0 : break;
493 : case KEY_MULTIPLY:
494 0 : rCursor.InsertElement(CDotElement);
495 0 : break;
496 : case KEY_DIVIDE:
497 0 : rCursor.InsertFraction();
498 0 : break;
499 : case KEY_LESS:
500 0 : rCursor.InsertElement(LessThanElement);
501 0 : break;
502 : case KEY_GREATER:
503 0 : rCursor.InsertElement(GreaterThanElement);
504 0 : break;
505 : case KEY_EQUAL:
506 0 : rCursor.InsertElement(EqualElement);
507 0 : break;
508 : default:
509 : {
510 0 : sal_Unicode code = rKEvt.GetCharCode();
511 0 : SmBraceNode* pBraceNode = NULL;
512 :
513 0 : if(code == ' ') {
514 0 : rCursor.InsertElement(BlankElement);
515 0 : }else if(code == '^') {
516 0 : rCursor.InsertSubSup(RSUP);
517 0 : }else if(code == '(') {
518 0 : rCursor.InsertBrackets(RoundBrackets);
519 0 : }else if(code == '[') {
520 0 : rCursor.InsertBrackets(SquareBrackets);
521 0 : }else if(code == '{') {
522 0 : rCursor.InsertBrackets(CurlyBrackets);
523 0 : }else if(code == '!') {
524 0 : rCursor.InsertElement(FactorialElement);
525 0 : }else if(code == '%') {
526 0 : rCursor.InsertElement(PercentElement);
527 0 : }else if(code == ')' && rCursor.IsAtTailOfBracket(RoundBrackets, &pBraceNode)) {
528 0 : rCursor.MoveAfterBracket(pBraceNode);
529 0 : }else if(code == ']' && rCursor.IsAtTailOfBracket(SquareBrackets, &pBraceNode)) {
530 0 : rCursor.MoveAfterBracket(pBraceNode);
531 0 : }else if(code == '}' && rCursor.IsAtTailOfBracket(CurlyBrackets, &pBraceNode)) {
532 0 : rCursor.MoveAfterBracket(pBraceNode);
533 : }else{
534 0 : if(code != 0){
535 0 : rCursor.InsertText(OUString(code));
536 0 : }else if (! (GetView() && GetView()->KeyInput(rKEvt)) )
537 0 : ScrollableWindow::KeyInput(rKEvt);
538 : }
539 : }
540 : }
541 : }
542 0 : CaretBlinkStop();
543 0 : CaretBlinkStart();
544 0 : SetIsCursorVisible(true);
545 0 : RepaintViewShellDoc();
546 : }
547 :
548 :
549 0 : void SmGraphicWindow::Command(const CommandEvent& rCEvt)
550 : {
551 0 : bool bCallBase = true;
552 0 : if ( !pViewShell->GetViewFrame()->GetFrame().IsInPlace() )
553 : {
554 0 : switch ( rCEvt.GetCommand() )
555 : {
556 : case COMMAND_CONTEXTMENU:
557 : {
558 0 : GetParent()->ToTop();
559 0 : SmResId aResId( RID_VIEWMENU );
560 0 : PopupMenu* pPopupMenu = new PopupMenu(aResId);
561 0 : pPopupMenu->SetSelectHdl(LINK(this, SmGraphicWindow, MenuSelectHdl));
562 0 : Point aPos(5, 5);
563 0 : if (rCEvt.IsMouseEvent())
564 0 : aPos = rCEvt.GetMousePosPixel();
565 : OSL_ENSURE( pViewShell, "view shell missing" );
566 :
567 : // added for replaceability of context menus
568 0 : pViewShell->GetViewFrame()->GetBindings().GetDispatcher()
569 0 : ->ExecutePopup( aResId, this, &aPos );
570 :
571 0 : delete pPopupMenu;
572 0 : bCallBase = false;
573 : }
574 0 : break;
575 :
576 : case COMMAND_WHEEL:
577 : {
578 0 : const CommandWheelData* pWData = rCEvt.GetWheelData();
579 0 : if ( pWData && COMMAND_WHEEL_ZOOM == pWData->GetMode() )
580 : {
581 0 : sal_uInt16 nTmpZoom = GetZoom();
582 0 : if( 0L > pWData->GetDelta() )
583 0 : nTmpZoom -= 10;
584 : else
585 0 : nTmpZoom += 10;
586 0 : SetZoom( nTmpZoom );
587 0 : bCallBase = false;
588 : }
589 : }
590 0 : break;
591 : }
592 : }
593 0 : if ( bCallBase )
594 0 : ScrollableWindow::Command (rCEvt);
595 0 : }
596 :
597 :
598 0 : IMPL_LINK_INLINE_START( SmGraphicWindow, MenuSelectHdl, Menu *, pMenu )
599 : {
600 0 : SmViewShell *pViewSh = GetView();
601 0 : if (pViewSh)
602 0 : pViewSh->GetViewFrame()->GetDispatcher()->Execute( pMenu->GetCurItemId() );
603 0 : return 0;
604 : }
605 0 : IMPL_LINK_INLINE_END( SmGraphicWindow, MenuSelectHdl, Menu *, pMenu )
606 :
607 :
608 8 : void SmGraphicWindow::SetZoom(sal_uInt16 Factor)
609 : {
610 8 : nZoom = std::min(std::max((sal_uInt16) Factor, (sal_uInt16) MINZOOM), (sal_uInt16) MAXZOOM);
611 8 : Fraction aFraction (nZoom, 100);
612 8 : SetMapMode( MapMode(MAP_100TH_MM, Point(), aFraction, aFraction) );
613 8 : SetTotalSize();
614 8 : SmViewShell *pViewSh = GetView();
615 8 : if (pViewSh)
616 : {
617 8 : pViewSh->GetViewFrame()->GetBindings().Invalidate(SID_ATTR_ZOOM);
618 8 : pViewSh->GetViewFrame()->GetBindings().Invalidate(SID_ATTR_ZOOMSLIDER);
619 : }
620 8 : Invalidate();
621 8 : }
622 :
623 :
624 2 : void SmGraphicWindow::ZoomToFitInWindow()
625 : {
626 2 : SmDocShell &rDoc = *pViewShell->GetDoc();
627 :
628 : // set defined mapmode before calling 'LogicToPixel' below
629 2 : SetMapMode(MapMode(MAP_100TH_MM));
630 :
631 2 : Size aSize (LogicToPixel(rDoc.GetSize()));
632 2 : Size aWindowSize (GetSizePixel());
633 :
634 2 : if (aSize.Width() > 0 && aSize.Height() > 0)
635 : {
636 2 : long nVal = std::min ((85 * aWindowSize.Width()) / aSize.Width(),
637 4 : (85 * aWindowSize.Height()) / aSize.Height());
638 2 : SetZoom ( sal::static_int_cast< sal_uInt16 >(nVal) );
639 : }
640 2 : }
641 :
642 3 : uno::Reference< XAccessible > SmGraphicWindow::CreateAccessible()
643 : {
644 3 : if (!pAccessible)
645 : {
646 3 : pAccessible = new SmGraphicAccessible( this );
647 3 : xAccessible = pAccessible;
648 : }
649 3 : return xAccessible;
650 : }
651 :
652 : /**************************************************************************/
653 :
654 :
655 21 : SmGraphicController::SmGraphicController(SmGraphicWindow &rSmGraphic,
656 : sal_uInt16 nId_,
657 : SfxBindings &rBindings) :
658 : SfxControllerItem(nId_, rBindings),
659 21 : rGraphic(rSmGraphic)
660 : {
661 21 : }
662 :
663 :
664 3 : void SmGraphicController::StateChanged(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState)
665 : {
666 3 : rGraphic.SetTotalSize();
667 3 : rGraphic.Invalidate();
668 3 : SfxControllerItem::StateChanged (nSID, eState, pState);
669 3 : }
670 :
671 :
672 : /**************************************************************************/
673 :
674 :
675 21 : SmEditController::SmEditController(SmEditWindow &rSmEdit,
676 : sal_uInt16 nId_,
677 : SfxBindings &rBindings) :
678 : SfxControllerItem(nId_, rBindings),
679 21 : rEdit(rSmEdit)
680 : {
681 21 : }
682 :
683 :
684 : #if OSL_DEBUG_LEVEL > 1
685 : SmEditController::~SmEditController()
686 : {
687 : }
688 : #endif
689 :
690 :
691 3 : void SmEditController::StateChanged(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState)
692 : {
693 3 : const SfxStringItem *pItem = PTR_CAST(SfxStringItem, pState);
694 :
695 3 : if ((pItem != NULL) && (rEdit.GetText() != OUString(pItem->GetValue())))
696 2 : rEdit.SetText(pItem->GetValue());
697 3 : SfxControllerItem::StateChanged (nSID, eState, pState);
698 3 : }
699 :
700 :
701 : /**************************************************************************/
702 :
703 21 : SmCmdBoxWindow::SmCmdBoxWindow(SfxBindings *pBindings_, SfxChildWindow *pChildWindow,
704 : Window *pParent) :
705 : SfxDockingWindow(pBindings_, pChildWindow, pParent, SmResId(RID_CMDBOXWINDOW)),
706 : aEdit (*this),
707 : aController (aEdit, SID_TEXT, *pBindings_),
708 21 : bExiting (false)
709 : {
710 21 : Hide ();
711 :
712 21 : aInitialFocusTimer.SetTimeoutHdl(LINK(this, SmCmdBoxWindow, InitialFocusTimerHdl));
713 21 : aInitialFocusTimer.SetTimeout(100);
714 21 : }
715 :
716 :
717 63 : SmCmdBoxWindow::~SmCmdBoxWindow ()
718 : {
719 21 : aInitialFocusTimer.Stop();
720 21 : bExiting = true;
721 42 : }
722 :
723 :
724 131 : SmViewShell * SmCmdBoxWindow::GetView()
725 : {
726 131 : SfxDispatcher *pDispatcher = GetBindings().GetDispatcher();
727 131 : SfxViewShell *pView = pDispatcher ? pDispatcher->GetFrame()->GetViewShell() : NULL;
728 131 : return PTR_CAST(SmViewShell, pView);
729 : }
730 :
731 34 : void SmCmdBoxWindow::Resize()
732 : {
733 34 : Rectangle aRect = Rectangle(Point(0, 0), GetOutputSizePixel());
734 34 : aRect.Left() += CMD_BOX_PADDING;
735 34 : aRect.Top() += CMD_BOX_PADDING;
736 34 : aRect.Right() -= CMD_BOX_PADDING;
737 34 : aRect.Bottom() -= CMD_BOX_PADDING;
738 :
739 34 : DecorationView aView(this);
740 34 : aRect = aView.DrawFrame( aRect, FRAME_DRAW_IN | FRAME_DRAW_NODRAW );
741 :
742 34 : aEdit.SetPosSizePixel(aRect.TopLeft(), aRect.GetSize());
743 34 : SfxDockingWindow::Resize();
744 34 : Invalidate();
745 34 : }
746 :
747 :
748 21 : void SmCmdBoxWindow::Paint(const Rectangle& /*rRect*/)
749 : {
750 21 : Rectangle aRect = Rectangle(Point(0, 0), GetOutputSizePixel());
751 21 : aRect.Left() += CMD_BOX_PADDING;
752 21 : aRect.Top() += CMD_BOX_PADDING;
753 21 : aRect.Right() -= CMD_BOX_PADDING;
754 21 : aRect.Bottom() -= CMD_BOX_PADDING;
755 :
756 21 : DecorationView aView(this);
757 21 : aView.DrawFrame( aRect, FRAME_DRAW_IN );
758 21 : }
759 :
760 :
761 0 : Size SmCmdBoxWindow::CalcDockingSize(SfxChildAlignment eAlign)
762 : {
763 0 : switch (eAlign)
764 : {
765 : case SFX_ALIGN_LEFT:
766 : case SFX_ALIGN_RIGHT:
767 0 : return Size();
768 : default:
769 0 : break;
770 : }
771 0 : return SfxDockingWindow::CalcDockingSize(eAlign);
772 : }
773 :
774 :
775 15 : SfxChildAlignment SmCmdBoxWindow::CheckAlignment(SfxChildAlignment eActual,
776 : SfxChildAlignment eWish)
777 : {
778 15 : switch (eWish)
779 : {
780 : case SFX_ALIGN_TOP:
781 : case SFX_ALIGN_BOTTOM:
782 : case SFX_ALIGN_NOALIGNMENT:
783 15 : return eWish;
784 : default:
785 0 : break;
786 : }
787 :
788 0 : return eActual;
789 : }
790 :
791 :
792 72 : void SmCmdBoxWindow::StateChanged( StateChangedType nStateChange )
793 : {
794 72 : if (STATE_CHANGE_INITSHOW == nStateChange)
795 : {
796 17 : Resize(); // avoid SmEditWindow not being painted correctly
797 :
798 : // set initial position of window in floating mode
799 17 : if (IsFloatingMode())
800 0 : AdjustPosition(); //! don't change pos in docking-mode !
801 :
802 17 : aInitialFocusTimer.Start();
803 : }
804 :
805 72 : SfxDockingWindow::StateChanged( nStateChange );
806 72 : }
807 :
808 :
809 20 : IMPL_LINK( SmCmdBoxWindow, InitialFocusTimerHdl, Timer *, EMPTYARG /*pTimer*/ )
810 : {
811 : // We want to have the focus in the edit window once Math has been opened
812 : // to allow for immediate typing.
813 : // Problem: There is no proper way to do this
814 : // Thus: this timer based soultion has been implemented (see GrabFocus below)
815 : //
816 : // Follow-up problem (#i114910): grabing the focus may bust the help system since
817 : // it relies on getting the current frame which conflicts with grabbing the focus.
818 : // Thus aside from the 'GrabFocus' call everything else is to get the
819 : // help reliably working despite using 'GrabFocus'.
820 :
821 : try
822 : {
823 10 : uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( comphelper::getProcessComponentContext() );
824 :
825 10 : aEdit.GrabFocus();
826 :
827 10 : bool bInPlace = GetView()->GetViewFrame()->GetFrame().IsInPlace();
828 20 : uno::Reference< frame::XFrame > xFrame( GetBindings().GetDispatcher()->GetFrame()->GetFrame().GetFrameInterface());
829 10 : if ( bInPlace )
830 : {
831 0 : uno::Reference< container::XChild > xModel( GetView()->GetDoc()->GetModel(), uno::UNO_QUERY_THROW );
832 0 : uno::Reference< frame::XModel > xParent( xModel->getParent(), uno::UNO_QUERY_THROW );
833 0 : uno::Reference< frame::XController > xParentCtrler( xParent->getCurrentController() );
834 0 : uno::Reference< frame::XFramesSupplier > xParentFrame( xParentCtrler->getFrame(), uno::UNO_QUERY_THROW );
835 0 : xParentFrame->setActiveFrame( xFrame );
836 : }
837 : else
838 : {
839 10 : xDesktop->setActiveFrame( xFrame );
840 10 : }
841 : }
842 0 : catch (uno::Exception &)
843 : {
844 : SAL_WARN( "starmath", "failed to properly set initial focus to edit window" );
845 : }
846 10 : return 0;
847 : }
848 :
849 :
850 0 : void SmCmdBoxWindow::AdjustPosition()
851 : {
852 0 : Point aPt;
853 0 : const Rectangle aRect( aPt, GetParent()->GetOutputSizePixel() );
854 : Point aTopLeft( Point( aRect.Left(),
855 0 : aRect.Bottom() - GetSizePixel().Height() ) );
856 0 : Point aPos( GetParent()->OutputToScreenPixel( aTopLeft ) );
857 0 : if (aPos.X() < 0)
858 0 : aPos.X() = 0;
859 0 : if (aPos.Y() < 0)
860 0 : aPos.Y() = 0;
861 0 : SetPosPixel( aPos );
862 0 : }
863 :
864 :
865 0 : void SmCmdBoxWindow::ToggleFloatingMode()
866 : {
867 0 : SfxDockingWindow::ToggleFloatingMode();
868 :
869 0 : if (GetFloatingWindow())
870 0 : GetFloatingWindow()->SetMinOutputSizePixel(Size (200, 50));
871 0 : }
872 :
873 :
874 15 : void SmCmdBoxWindow::GetFocus()
875 : {
876 15 : if (!bExiting)
877 0 : aEdit.GrabFocus();
878 15 : }
879 :
880 : /**************************************************************************/
881 :
882 :
883 284 : SFX_IMPL_DOCKINGWINDOW_WITHID(SmCmdBoxWrapper, SID_CMDBOXWINDOW);
884 :
885 17 : SmCmdBoxWrapper::SmCmdBoxWrapper(Window *pParentWindow, sal_uInt16 nId,
886 : SfxBindings *pBindings,
887 : SfxChildWinInfo *pInfo) :
888 17 : SfxChildWindow(pParentWindow, nId)
889 : {
890 17 : pWindow = new SmCmdBoxWindow(pBindings, this, pParentWindow);
891 :
892 : // make window docked to the bottom initially (after first start)
893 17 : eChildAlignment = SFX_ALIGN_BOTTOM;
894 17 : ((SfxDockingWindow *)pWindow)->Initialize(pInfo);
895 17 : }
896 :
897 :
898 : #if OSL_DEBUG_LEVEL > 1
899 : SmCmdBoxWrapper::~SmCmdBoxWrapper()
900 : {
901 : }
902 : #endif
903 :
904 :
905 : /**************************************************************************/
906 :
907 : struct SmViewShell_Impl
908 : {
909 : sfx2::DocumentInserter* pDocInserter;
910 : SfxRequest* pRequest;
911 : SvtMiscOptions aOpts;
912 :
913 21 : SmViewShell_Impl() :
914 : pDocInserter( NULL )
915 21 : , pRequest( NULL )
916 21 : {}
917 :
918 17 : ~SmViewShell_Impl()
919 17 : {
920 17 : delete pDocInserter;
921 17 : delete pRequest;
922 17 : }
923 : };
924 :
925 869 : TYPEINIT1( SmViewShell, SfxViewShell );
926 :
927 1702 : SFX_IMPL_INTERFACE(SmViewShell, SfxViewShell, SmResId(0))
928 : {
929 14 : SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_TOOLS | SFX_VISIBILITY_STANDARD |
930 : SFX_VISIBILITY_FULLSCREEN | SFX_VISIBILITY_SERVER,
931 7 : SmResId(RID_MATH_TOOLBOX ));
932 : //Dummy-Objectbar, to avoid quiver while activating
933 :
934 7 : SFX_CHILDWINDOW_REGISTRATION(SID_TASKPANE);
935 7 : SFX_CHILDWINDOW_REGISTRATION(SmToolBoxWrapper::GetChildWindowId());
936 7 : SFX_CHILDWINDOW_REGISTRATION(SmCmdBoxWrapper::GetChildWindowId());
937 7 : SFX_CHILDWINDOW_REGISTRATION(SmElementsDockingWindowWrapper::GetChildWindowId());
938 7 : }
939 :
940 :
941 35 : SFX_IMPL_NAMED_VIEWFACTORY(SmViewShell, "Default")
942 : {
943 7 : SFX_VIEW_REGISTRATION(SmDocShell);
944 7 : }
945 :
946 :
947 0 : void SmViewShell::AdjustPosSizePixel(const Point &rPos, const Size &rSize)
948 : {
949 : SAL_INFO( "starmath", "starmath: SmViewShell::AdjustPosSizePixel" );
950 :
951 0 : aGraphic.SetPosSizePixel(rPos, rSize);
952 0 : }
953 :
954 :
955 0 : void SmViewShell::InnerResizePixel(const Point &rOfs, const Size &rSize)
956 : {
957 : SAL_INFO( "starmath", "starmath: SmViewShell::InnerResizePixel" );
958 :
959 0 : Size aObjSize = GetObjectShell()->GetVisArea().GetSize();
960 0 : if ( aObjSize.Width() > 0 && aObjSize.Height() > 0 )
961 : {
962 0 : Size aProvidedSize = GetWindow()->PixelToLogic( rSize, MAP_100TH_MM );
963 0 : SfxViewShell::SetZoomFactor( Fraction( aProvidedSize.Width(), aObjSize.Width() ),
964 0 : Fraction( aProvidedSize.Height(), aObjSize.Height() ) );
965 : }
966 :
967 0 : SetBorderPixel( SvBorder() );
968 0 : GetGraphicWindow().SetPosSizePixel(rOfs, rSize);
969 0 : GetGraphicWindow().SetTotalSize();
970 0 : }
971 :
972 :
973 38 : void SmViewShell::OuterResizePixel(const Point &rOfs, const Size &rSize)
974 : {
975 : SAL_INFO( "starmath", "starmath: SmViewShell::OuterResizePixel" );
976 :
977 38 : SmGraphicWindow &rWin = GetGraphicWindow();
978 38 : rWin.SetPosSizePixel(rOfs, rSize);
979 38 : if (GetDoc()->IsPreview())
980 0 : rWin.ZoomToFitInWindow();
981 38 : rWin.Update();
982 38 : }
983 :
984 :
985 0 : void SmViewShell::QueryObjAreaPixel( Rectangle& rRect ) const
986 : {
987 : SAL_INFO( "starmath", "starmath: SmViewShell::QueryObjAreaPixel" );
988 :
989 0 : rRect.SetSize( GetGraphicWindow().GetSizePixel() );
990 0 : }
991 :
992 :
993 0 : void SmViewShell::SetZoomFactor( const Fraction &rX, const Fraction &rY )
994 : {
995 : SAL_INFO( "starmath", "starmath: SmViewShell::SetZoomFactor" );
996 :
997 0 : const Fraction &rFrac = rX < rY ? rX : rY;
998 0 : GetGraphicWindow().SetZoom( (sal_uInt16) long(rFrac * Fraction( 100, 1 )) );
999 :
1000 : //To avoid rounding errors base class regulates crooked values too
1001 : //if necessary
1002 0 : SfxViewShell::SetZoomFactor( rX, rY );
1003 0 : }
1004 :
1005 :
1006 0 : Size SmViewShell::GetTextLineSize(OutputDevice& rDevice, const String& rLine)
1007 : {
1008 : SAL_INFO( "starmath", "starmath: SmViewShell::GetTextLineSize" );
1009 :
1010 0 : Size aSize(rDevice.GetTextWidth(rLine), rDevice.GetTextHeight());
1011 0 : sal_uInt16 nTabs = comphelper::string::getTokenCount(rLine, '\t');
1012 :
1013 0 : if (nTabs > 0)
1014 : {
1015 0 : long TabPos = rDevice.GetTextWidth(OUString('n')) * 8;
1016 :
1017 0 : aSize.Width() = 0;
1018 :
1019 0 : for (sal_uInt16 i = 0; i < nTabs; i++)
1020 : {
1021 0 : if (i > 0)
1022 0 : aSize.Width() = ((aSize.Width() / TabPos) + 1) * TabPos;
1023 :
1024 0 : OUString aText = rLine.GetToken(i, '\t');
1025 0 : aText = comphelper::string::stripStart(aText, '\t');
1026 0 : aText = comphelper::string::stripEnd(aText, '\t');
1027 0 : aSize.Width() += rDevice.GetTextWidth(aText);
1028 0 : }
1029 : }
1030 :
1031 0 : return aSize;
1032 : }
1033 :
1034 :
1035 0 : Size SmViewShell::GetTextSize(OutputDevice& rDevice, const String& rText, long MaxWidth)
1036 : {
1037 : SAL_INFO( "starmath", "starmath: SmViewShell::GetTextSize" );
1038 :
1039 0 : Size aSize;
1040 0 : Size TextSize;
1041 0 : sal_uInt16 nLines = comphelper::string::getTokenCount(rText, '\n');
1042 :
1043 0 : for (sal_uInt16 i = 0; i < nLines; i++)
1044 : {
1045 0 : OUString aLine = rText.GetToken(i, '\n');
1046 0 : aLine = comphelper::string::remove(aLine, '\r');
1047 0 : aLine = comphelper::string::stripStart(aLine, '\n');
1048 0 : aLine = comphelper::string::stripEnd(aLine, '\n');
1049 :
1050 0 : aSize = GetTextLineSize(rDevice, aLine);
1051 :
1052 0 : if (aSize.Width() > MaxWidth)
1053 : {
1054 0 : do
1055 : {
1056 0 : OUString aText;
1057 0 : sal_Int32 m = aLine.getLength();
1058 0 : sal_Int32 nLen = m;
1059 :
1060 0 : for (sal_Int32 n = 0; n < nLen; n++)
1061 : {
1062 0 : sal_Unicode cLineChar = aLine[n];
1063 0 : if ((cLineChar == ' ') || (cLineChar == '\t'))
1064 : {
1065 0 : aText = aLine.copy(0, n);
1066 0 : if (GetTextLineSize(rDevice, aText).Width() < MaxWidth)
1067 0 : m = n;
1068 : else
1069 0 : break;
1070 : }
1071 : }
1072 :
1073 0 : aText = aLine.copy(0, m);
1074 0 : aLine = aLine.replaceAt(0, m, "");
1075 0 : aSize = GetTextLineSize(rDevice, aText);
1076 0 : TextSize.Height() += aSize.Height();
1077 0 : TextSize.Width() = std::max(TextSize.Width(), std::min(aSize.Width(), MaxWidth));
1078 :
1079 0 : aLine = comphelper::string::stripStart(aLine, ' ');
1080 0 : aLine = comphelper::string::stripStart(aLine, '\t');
1081 0 : aLine = comphelper::string::stripStart(aLine, ' ');
1082 : }
1083 0 : while (!aLine.isEmpty());
1084 : }
1085 : else
1086 : {
1087 0 : TextSize.Height() += aSize.Height();
1088 0 : TextSize.Width() = std::max(TextSize.Width(), aSize.Width());
1089 : }
1090 0 : }
1091 :
1092 0 : return TextSize;
1093 : }
1094 :
1095 :
1096 0 : void SmViewShell::DrawTextLine(OutputDevice& rDevice, const Point& rPosition, const String& rLine)
1097 : {
1098 : SAL_INFO( "starmath", "starmath: SmViewShell::DrawTextLine" );
1099 :
1100 0 : Point aPoint (rPosition);
1101 0 : sal_uInt16 nTabs = comphelper::string::getTokenCount(rLine, '\t');
1102 :
1103 0 : if (nTabs > 0)
1104 : {
1105 0 : long TabPos = rDevice.GetTextWidth(OUString('n')) * 8;
1106 :
1107 0 : for (sal_uInt16 i = 0; i < nTabs; i++)
1108 : {
1109 0 : if (i > 0)
1110 0 : aPoint.X() = ((aPoint.X() / TabPos) + 1) * TabPos;
1111 :
1112 0 : OUString aText = rLine.GetToken(i, '\t');
1113 0 : aText = comphelper::string::stripStart(aText, '\t');
1114 0 : aText = comphelper::string::stripEnd(aText, '\t');
1115 0 : rDevice.DrawText(aPoint, aText);
1116 0 : aPoint.X() += rDevice.GetTextWidth(aText);
1117 0 : }
1118 : }
1119 : else
1120 0 : rDevice.DrawText(aPoint, rLine);
1121 0 : }
1122 :
1123 :
1124 0 : void SmViewShell::DrawText(OutputDevice& rDevice, const Point& rPosition, const String& rText, sal_uInt16 MaxWidth)
1125 : {
1126 : SAL_INFO( "starmath", "starmath: SmViewShell::DrawText" );
1127 :
1128 0 : sal_uInt16 nLines = comphelper::string::getTokenCount(rText, '\n');
1129 0 : Point aPoint (rPosition);
1130 0 : Size aSize;
1131 :
1132 0 : for (sal_uInt16 i = 0; i < nLines; i++)
1133 : {
1134 0 : OUString aLine = rText.GetToken(i, '\n');
1135 0 : aLine = comphelper::string::remove(aLine, '\r');
1136 0 : aLine = comphelper::string::stripEnd(aLine, '\n');
1137 0 : aLine = comphelper::string::stripEnd(aLine, '\n');
1138 0 : aSize = GetTextLineSize(rDevice, aLine);
1139 0 : if (aSize.Width() > MaxWidth)
1140 : {
1141 0 : do
1142 : {
1143 0 : OUString aText;
1144 0 : sal_Int32 m = aLine.getLength();
1145 0 : sal_Int32 nLen = m;
1146 :
1147 0 : for (sal_Int32 n = 0; n < nLen; n++)
1148 : {
1149 0 : sal_Unicode cLineChar = aLine[n];
1150 0 : if ((cLineChar == ' ') || (cLineChar == '\t'))
1151 : {
1152 0 : aText = aLine.copy(0, n);
1153 0 : if (GetTextLineSize(rDevice, aText).Width() < MaxWidth)
1154 0 : m = n;
1155 : else
1156 0 : break;
1157 : }
1158 : }
1159 0 : aText = aLine.copy(0, m);
1160 0 : aLine = aLine.replaceAt(0, m, "");
1161 :
1162 0 : DrawTextLine(rDevice, aPoint, aText);
1163 0 : aPoint.Y() += aSize.Height();
1164 :
1165 0 : aLine = comphelper::string::stripStart(aLine, ' ');
1166 0 : aLine = comphelper::string::stripStart(aLine, '\t');
1167 0 : aLine = comphelper::string::stripStart(aLine, ' ');
1168 : }
1169 0 : while (GetTextLineSize(rDevice, aLine).Width() > MaxWidth);
1170 :
1171 : // print the remaining text
1172 0 : if (!aLine.isEmpty())
1173 : {
1174 0 : DrawTextLine(rDevice, aPoint, aLine);
1175 0 : aPoint.Y() += aSize.Height();
1176 : }
1177 : }
1178 : else
1179 : {
1180 0 : DrawTextLine(rDevice, aPoint, aLine);
1181 0 : aPoint.Y() += aSize.Height();
1182 : }
1183 0 : }
1184 0 : }
1185 :
1186 0 : void SmViewShell::Impl_Print(
1187 : OutputDevice &rOutDev,
1188 : const SmPrintUIOptions &rPrintUIOptions,
1189 : Rectangle aOutRect, Point aZeroPoint )
1190 : {
1191 : SAL_INFO( "starmath", "starmath: SmViewShell::Impl_Print" );
1192 :
1193 0 : const bool bIsPrintTitle = rPrintUIOptions.getBoolValue( PRTUIOPT_TITLE_ROW, sal_True );
1194 0 : const bool bIsPrintFrame = rPrintUIOptions.getBoolValue( PRTUIOPT_BORDER, sal_True );
1195 0 : const bool bIsPrintFormulaText = rPrintUIOptions.getBoolValue( PRTUIOPT_FORMULA_TEXT, sal_True );
1196 0 : SmPrintSize ePrintSize( static_cast< SmPrintSize >( rPrintUIOptions.getIntValue( PRTUIOPT_PRINT_FORMAT, PRINT_SIZE_NORMAL ) ));
1197 0 : const sal_uInt16 nZoomFactor = static_cast< sal_uInt16 >(rPrintUIOptions.getIntValue( PRTUIOPT_PRINT_SCALE, 100 ));
1198 :
1199 0 : rOutDev.Push();
1200 0 : rOutDev.SetLineColor( Color(COL_BLACK) );
1201 :
1202 : // output text on top
1203 0 : if (bIsPrintTitle)
1204 : {
1205 0 : Size aSize600 (0, 600);
1206 0 : Size aSize650 (0, 650);
1207 0 : Font aFont(FAMILY_DONTKNOW, aSize600);
1208 :
1209 0 : aFont.SetAlign(ALIGN_TOP);
1210 0 : aFont.SetWeight(WEIGHT_BOLD);
1211 0 : aFont.SetSize(aSize650);
1212 0 : aFont.SetColor( Color(COL_BLACK) );
1213 0 : rOutDev.SetFont(aFont);
1214 :
1215 0 : Size aTitleSize (GetTextSize(rOutDev, GetDoc()->GetTitle(), aOutRect.GetWidth() - 200));
1216 :
1217 0 : aFont.SetWeight(WEIGHT_NORMAL);
1218 0 : aFont.SetSize(aSize600);
1219 0 : rOutDev.SetFont(aFont);
1220 :
1221 0 : Size aDescSize (GetTextSize(rOutDev, GetDoc()->GetComment(), aOutRect.GetWidth() - 200));
1222 :
1223 0 : if (bIsPrintFrame)
1224 : rOutDev.DrawRect(Rectangle(aOutRect.TopLeft(),
1225 0 : Size(aOutRect.GetWidth(), 100 + aTitleSize.Height() + 200 + aDescSize.Height() + 100)));
1226 0 : aOutRect.Top() += 200;
1227 :
1228 : // output title
1229 0 : aFont.SetWeight(WEIGHT_BOLD);
1230 0 : aFont.SetSize(aSize650);
1231 0 : rOutDev.SetFont(aFont);
1232 0 : Point aPoint(aOutRect.Left() + (aOutRect.GetWidth() - aTitleSize.Width()) / 2,
1233 0 : aOutRect.Top());
1234 0 : DrawText(rOutDev, aPoint, GetDoc()->GetTitle(),
1235 0 : sal::static_int_cast< sal_uInt16 >(aOutRect.GetWidth() - 200));
1236 0 : aOutRect.Top() += aTitleSize.Height() + 200;
1237 :
1238 : // output description
1239 0 : aFont.SetWeight(WEIGHT_NORMAL);
1240 0 : aFont.SetSize(aSize600);
1241 0 : rOutDev.SetFont(aFont);
1242 0 : aPoint.X() = aOutRect.Left() + (aOutRect.GetWidth() - aDescSize.Width()) / 2;
1243 0 : aPoint.Y() = aOutRect.Top();
1244 : DrawText(rOutDev, aPoint, GetDoc()->GetComment(),
1245 0 : sal::static_int_cast< sal_uInt16 >(aOutRect.GetWidth() - 200));
1246 0 : aOutRect.Top() += aDescSize.Height() + 300;
1247 : }
1248 :
1249 : // output text on bottom
1250 0 : if (bIsPrintFormulaText)
1251 : {
1252 0 : Font aFont(FAMILY_DONTKNOW, Size(0, 600));
1253 0 : aFont.SetAlign(ALIGN_TOP);
1254 0 : aFont.SetColor( Color(COL_BLACK) );
1255 :
1256 : // get size
1257 0 : rOutDev.SetFont(aFont);
1258 :
1259 0 : Size aSize (GetTextSize(rOutDev, GetDoc()->GetText(), aOutRect.GetWidth() - 200));
1260 :
1261 0 : aOutRect.Bottom() -= aSize.Height() + 600;
1262 :
1263 0 : if (bIsPrintFrame)
1264 : rOutDev.DrawRect(Rectangle(aOutRect.BottomLeft(),
1265 0 : Size(aOutRect.GetWidth(), 200 + aSize.Height() + 200)));
1266 :
1267 0 : Point aPoint (aOutRect.Left() + (aOutRect.GetWidth() - aSize.Width()) / 2,
1268 0 : aOutRect.Bottom() + 300);
1269 : DrawText(rOutDev, aPoint, GetDoc()->GetText(),
1270 0 : sal::static_int_cast< sal_uInt16 >(aOutRect.GetWidth() - 200));
1271 0 : aOutRect.Bottom() -= 200;
1272 : }
1273 :
1274 0 : if (bIsPrintFrame)
1275 0 : rOutDev.DrawRect(aOutRect);
1276 :
1277 0 : aOutRect.Top() += 100;
1278 0 : aOutRect.Left() += 100;
1279 0 : aOutRect.Bottom() -= 100;
1280 0 : aOutRect.Right() -= 100;
1281 :
1282 0 : Size aSize (GetDoc()->GetSize());
1283 :
1284 0 : MapMode OutputMapMode;
1285 : // PDF export should always use PRINT_SIZE_NORMAL ...
1286 0 : if (!rPrintUIOptions.getBoolValue( "IsPrinter", sal_False ) )
1287 0 : ePrintSize = PRINT_SIZE_NORMAL;
1288 0 : switch (ePrintSize)
1289 : {
1290 : case PRINT_SIZE_NORMAL:
1291 0 : OutputMapMode = MapMode(MAP_100TH_MM);
1292 0 : break;
1293 :
1294 : case PRINT_SIZE_SCALED:
1295 0 : if ((aSize.Width() > 0) && (aSize.Height() > 0))
1296 : {
1297 : Size OutputSize (rOutDev.LogicToPixel(Size(aOutRect.GetWidth(),
1298 0 : aOutRect.GetHeight()), MapMode(MAP_100TH_MM)));
1299 0 : Size GraphicSize (rOutDev.LogicToPixel(aSize, MapMode(MAP_100TH_MM)));
1300 0 : sal_uInt16 nZ = (sal_uInt16) std::min((long)Fraction(OutputSize.Width() * 100L, GraphicSize.Width()),
1301 0 : (long)Fraction(OutputSize.Height() * 100L, GraphicSize.Height()));
1302 0 : Fraction aFraction ((sal_uInt16) std::max ((sal_uInt16) MINZOOM, std::min((sal_uInt16) MAXZOOM, (sal_uInt16) (nZ - 10))), (sal_uInt16) 100);
1303 :
1304 0 : OutputMapMode = MapMode(MAP_100TH_MM, aZeroPoint, aFraction, aFraction);
1305 : }
1306 : else
1307 0 : OutputMapMode = MapMode(MAP_100TH_MM);
1308 0 : break;
1309 :
1310 : case PRINT_SIZE_ZOOMED:
1311 : {
1312 0 : Fraction aFraction( nZoomFactor, 100 );
1313 :
1314 0 : OutputMapMode = MapMode(MAP_100TH_MM, aZeroPoint, aFraction, aFraction);
1315 0 : break;
1316 : }
1317 : }
1318 :
1319 : aSize = rOutDev.PixelToLogic(rOutDev.LogicToPixel(aSize, OutputMapMode),
1320 0 : MapMode(MAP_100TH_MM));
1321 :
1322 0 : Point aPos (aOutRect.Left() + (aOutRect.GetWidth() - aSize.Width()) / 2,
1323 0 : aOutRect.Top() + (aOutRect.GetHeight() - aSize.Height()) / 2);
1324 :
1325 0 : aPos = rOutDev.PixelToLogic(rOutDev.LogicToPixel(aPos, MapMode(MAP_100TH_MM)),
1326 0 : OutputMapMode);
1327 0 : aOutRect = rOutDev.PixelToLogic(rOutDev.LogicToPixel(aOutRect, MapMode(MAP_100TH_MM)),
1328 0 : OutputMapMode);
1329 :
1330 0 : rOutDev.SetMapMode(OutputMapMode);
1331 0 : rOutDev.SetClipRegion(Region(aOutRect));
1332 0 : GetDoc()->DrawFormula(rOutDev, aPos, false);
1333 0 : rOutDev.SetClipRegion();
1334 :
1335 0 : rOutDev.Pop();
1336 0 : }
1337 :
1338 0 : sal_uInt16 SmViewShell::Print(SfxProgress & /*rProgress*/, sal_Bool /*bIsAPI*/)
1339 : {
1340 : SAL_INFO( "starmath", "starmath: SmViewShell::Print" );
1341 : SAL_WARN( "starmath", "SmViewShell::Print: no longer used with new UI print dialog. Should be removed!!" );
1342 0 : return 0;
1343 : }
1344 :
1345 :
1346 47 : SfxPrinter* SmViewShell::GetPrinter(sal_Bool bCreate)
1347 : {
1348 : SAL_INFO( "starmath", "starmath: SmViewShell::GetPrinter" );
1349 :
1350 47 : SmDocShell *pDoc = GetDoc();
1351 47 : if ( pDoc->HasPrinter() || bCreate )
1352 47 : return pDoc->GetPrinter();
1353 0 : return 0;
1354 : }
1355 :
1356 :
1357 0 : sal_uInt16 SmViewShell::SetPrinter(SfxPrinter *pNewPrinter, sal_uInt16 nDiffFlags, bool )
1358 : {
1359 : SAL_INFO( "starmath", "starmath: SmViewShell::SetPrinter" );
1360 0 : SfxPrinter *pOld = GetDoc()->GetPrinter();
1361 0 : if ( pOld && pOld->IsPrinting() )
1362 0 : return SFX_PRINTERROR_BUSY;
1363 :
1364 0 : if ((nDiffFlags & SFX_PRINTER_PRINTER) == SFX_PRINTER_PRINTER)
1365 0 : GetDoc()->SetPrinter( pNewPrinter );
1366 :
1367 0 : if ((nDiffFlags & SFX_PRINTER_OPTIONS) == SFX_PRINTER_OPTIONS)
1368 : {
1369 0 : SmModule *pp = SM_MOD();
1370 0 : pp->GetConfig()->ItemSetToConfig(pNewPrinter->GetOptions());
1371 : }
1372 0 : return 0;
1373 : }
1374 :
1375 0 : bool SmViewShell::HasPrintOptionsPage() const
1376 : {
1377 0 : return true;
1378 : }
1379 :
1380 0 : SfxTabPage* SmViewShell::CreatePrintOptionsPage(Window *pParent,
1381 : const SfxItemSet &rOptions)
1382 : {
1383 : SAL_INFO( "starmath", "starmath: SmViewShell::CreatePrintOptionsPage" );
1384 :
1385 0 : return SmPrintOptionsTabPage::Create(pParent, rOptions);
1386 : }
1387 :
1388 :
1389 236 : SmEditWindow *SmViewShell::GetEditWindow()
1390 : {
1391 : SAL_INFO( "starmath", "starmath: SmViewShell::GetEditWindow" );
1392 :
1393 : SmCmdBoxWrapper *pWrapper = (SmCmdBoxWrapper *) GetViewFrame()->
1394 236 : GetChildWindow( SmCmdBoxWrapper::GetChildWindowId() );
1395 :
1396 236 : if (pWrapper != NULL)
1397 : {
1398 143 : SmEditWindow *pEditWin = pWrapper->GetEditWindow();
1399 : OSL_ENSURE( pEditWin, "SmEditWindow missing" );
1400 143 : return pEditWin;
1401 : }
1402 :
1403 93 : return NULL;
1404 : }
1405 :
1406 :
1407 21 : void SmViewShell::SetStatusText(const OUString& rText)
1408 : {
1409 : SAL_INFO( "starmath", "starmath: SmViewShell::SetStatusText" );
1410 :
1411 21 : aStatusText = rText;
1412 21 : GetViewFrame()->GetBindings().Invalidate(SID_TEXTSTATUS);
1413 21 : }
1414 :
1415 :
1416 0 : void SmViewShell::ShowError( const SmErrorDesc *pErrorDesc )
1417 : {
1418 : SAL_INFO( "starmath", "starmath: SmViewShell::ShowError" );
1419 :
1420 : OSL_ENSURE(GetDoc(), "Sm : Document missing");
1421 0 : if (pErrorDesc || 0 != (pErrorDesc = GetDoc()->GetParser().GetError(0)) )
1422 : {
1423 0 : SetStatusText( pErrorDesc->Text );
1424 0 : GetEditWindow()->MarkError( Point( pErrorDesc->pNode->GetColumn(),
1425 0 : pErrorDesc->pNode->GetRow()));
1426 : }
1427 0 : }
1428 :
1429 :
1430 0 : void SmViewShell::NextError()
1431 : {
1432 : SAL_INFO( "starmath", "starmath: SmViewShell::NextError" );
1433 :
1434 : OSL_ENSURE(GetDoc(), "Sm : Document missing");
1435 0 : const SmErrorDesc *pErrorDesc = GetDoc()->GetParser().NextError();
1436 :
1437 0 : if (pErrorDesc)
1438 0 : ShowError( pErrorDesc );
1439 0 : }
1440 :
1441 :
1442 0 : void SmViewShell::PrevError()
1443 : {
1444 : SAL_INFO( "starmath", "starmath: SmViewShell::PrevError" );
1445 :
1446 : OSL_ENSURE(GetDoc(), "Sm : Document missing");
1447 0 : const SmErrorDesc *pErrorDesc = GetDoc()->GetParser().PrevError();
1448 :
1449 0 : if (pErrorDesc)
1450 0 : ShowError( pErrorDesc );
1451 0 : }
1452 :
1453 :
1454 0 : bool SmViewShell::Insert( SfxMedium& rMedium )
1455 : {
1456 : SAL_INFO( "starmath", "starmath: SmViewShell::Insert" );
1457 :
1458 0 : SmDocShell *pDoc = GetDoc();
1459 0 : bool bRet = false;
1460 :
1461 0 : uno::Reference < embed::XStorage > xStorage = rMedium.GetStorage();
1462 0 : uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY );
1463 0 : if ( xNameAccess.is() && xNameAccess->getElementNames().getLength() )
1464 : {
1465 0 : if ( xNameAccess->hasByName( OUString("content.xml") ) || xNameAccess->hasByName( OUString("Content.xml") ))
1466 : {
1467 : // is this a fabulous math package ?
1468 0 : Reference<com::sun::star::frame::XModel> xModel(pDoc->GetModel());
1469 0 : SmXMLImportWrapper aEquation(xModel); //!! modifies the result of pDoc->GetText() !!
1470 0 : bRet = 0 == aEquation.Import(rMedium);
1471 : }
1472 : }
1473 :
1474 0 : if( bRet )
1475 : {
1476 0 : OUString aText = pDoc->GetText();
1477 0 : SmEditWindow *pEditWin = GetEditWindow();
1478 0 : if (pEditWin)
1479 0 : pEditWin->InsertText( aText );
1480 : else
1481 : {
1482 : SAL_WARN( "starmath", "EditWindow missing" );
1483 : }
1484 :
1485 0 : pDoc->Parse();
1486 0 : pDoc->SetModified(true);
1487 :
1488 0 : SfxBindings &rBnd = GetViewFrame()->GetBindings();
1489 0 : rBnd.Invalidate(SID_GAPHIC_SM);
1490 0 : rBnd.Invalidate(SID_TEXT);
1491 : }
1492 0 : return bRet;
1493 : }
1494 :
1495 :
1496 0 : bool SmViewShell::InsertFrom(SfxMedium &rMedium)
1497 : {
1498 : SAL_INFO( "starmath", "starmath: SmViewShell::InsertFrom" );
1499 :
1500 0 : bool bSuccess = false;
1501 0 : SmDocShell *pDoc = GetDoc();
1502 0 : SvStream *pStream = rMedium.GetInStream();
1503 :
1504 0 : if (pStream)
1505 : {
1506 0 : const OUString& rFltName = rMedium.GetFilter()->GetFilterName();
1507 0 : if ( rFltName == MATHML_XML )
1508 : {
1509 0 : Reference<com::sun::star::frame::XModel> xModel( pDoc->GetModel() );
1510 0 : SmXMLImportWrapper aEquation(xModel); //!! modifies the result of pDoc->GetText() !!
1511 0 : bSuccess = 0 == aEquation.Import(rMedium);
1512 : }
1513 : }
1514 :
1515 0 : if( bSuccess )
1516 : {
1517 0 : OUString aText = pDoc->GetText();
1518 0 : SmEditWindow *pEditWin = GetEditWindow();
1519 0 : if (pEditWin)
1520 0 : pEditWin->InsertText( aText );
1521 : else
1522 : SAL_WARN( "starmath", "EditWindow missing" );
1523 :
1524 0 : pDoc->Parse();
1525 0 : pDoc->SetModified(true);
1526 :
1527 0 : SfxBindings &rBnd = GetViewFrame()->GetBindings();
1528 0 : rBnd.Invalidate(SID_GAPHIC_SM);
1529 0 : rBnd.Invalidate(SID_TEXT);
1530 : }
1531 :
1532 0 : return bSuccess;
1533 : }
1534 :
1535 :
1536 8 : void SmViewShell::Execute(SfxRequest& rReq)
1537 : {
1538 : SAL_INFO( "starmath", "starmath: SmViewShell::Execute" );
1539 :
1540 8 : SmEditWindow *pWin = GetEditWindow();
1541 :
1542 8 : switch (rReq.GetSlot())
1543 : {
1544 : case SID_FORMULACURSOR:
1545 : {
1546 0 : SmModule *pp = SM_MOD();
1547 :
1548 0 : const SfxItemSet *pArgs = rReq.GetArgs();
1549 : const SfxPoolItem *pItem;
1550 :
1551 : bool bVal;
1552 0 : if ( pArgs &&
1553 0 : SFX_ITEM_SET == pArgs->GetItemState( SID_FORMULACURSOR, false, &pItem))
1554 0 : bVal = ((SfxBoolItem *) pItem)->GetValue();
1555 : else
1556 0 : bVal = !pp->GetConfig()->IsShowFormulaCursor();
1557 :
1558 0 : pp->GetConfig()->SetShowFormulaCursor(bVal);
1559 0 : if (!IsInlineEditEnabled())
1560 0 : GetGraphicWindow().ShowCursor(bVal);
1561 0 : break;
1562 : }
1563 : case SID_DRAW:
1564 0 : if (pWin)
1565 : {
1566 0 : GetDoc()->SetText( pWin->GetText() );
1567 0 : SetStatusText(OUString());
1568 0 : ShowError( 0 );
1569 0 : GetDoc()->Repaint();
1570 : }
1571 0 : break;
1572 :
1573 : case SID_ZOOM_OPTIMAL:
1574 1 : aGraphic.ZoomToFitInWindow();
1575 1 : break;
1576 :
1577 : case SID_ZOOMIN:
1578 1 : aGraphic.SetZoom(aGraphic.GetZoom() + 25);
1579 1 : break;
1580 :
1581 : case SID_ZOOMOUT:
1582 : OSL_ENSURE(aGraphic.GetZoom() >= 25, "Sm: incorrect sal_uInt16 argument");
1583 2 : aGraphic.SetZoom(aGraphic.GetZoom() - 25);
1584 2 : break;
1585 :
1586 : case SID_COPYOBJECT:
1587 : {
1588 : //TODO/LATER: does not work because of UNO Tunneling - will be fixed later
1589 0 : Reference< datatransfer::XTransferable > xTrans( GetDoc()->GetModel(), uno::UNO_QUERY );
1590 0 : if( xTrans.is() )
1591 : {
1592 0 : Reference< lang::XUnoTunnel> xTnnl( xTrans, uno::UNO_QUERY);
1593 0 : if( xTnnl.is() )
1594 : {
1595 : TransferableHelper* pTrans = reinterpret_cast< TransferableHelper * >(
1596 : sal::static_int_cast< sal_uIntPtr >(
1597 0 : xTnnl->getSomething( TransferableHelper::getUnoTunnelId() )));
1598 0 : if( pTrans )
1599 0 : pTrans->CopyToClipboard( this ? GetEditWindow() : 0 );
1600 0 : }
1601 0 : }
1602 : }
1603 0 : break;
1604 :
1605 : case SID_PASTEOBJECT:
1606 : {
1607 0 : TransferableDataHelper aData( TransferableDataHelper::CreateFromSystemClipboard(this ? GetEditWindow(): 0) );
1608 0 : uno::Reference < io::XInputStream > xStrm;
1609 : SotFormatStringId nId;
1610 0 : if( aData.GetTransferable().is() &&
1611 0 : ( aData.HasFormat( nId = SOT_FORMATSTR_ID_EMBEDDED_OBJ ) ||
1612 0 : (aData.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) &&
1613 0 : aData.HasFormat( nId = SOT_FORMATSTR_ID_EMBED_SOURCE ))) &&
1614 0 : aData.GetInputStream( nId, xStrm ) && xStrm.is() )
1615 : {
1616 : try
1617 : {
1618 : uno::Reference < embed::XStorage > xStorage =
1619 0 : ::comphelper::OStorageHelper::GetStorageFromInputStream( xStrm, ::comphelper::getProcessComponentContext() );
1620 0 : uno::Reference < beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY );
1621 0 : SfxMedium aMedium( xStorage, OUString() );
1622 0 : Insert( aMedium );
1623 0 : GetDoc()->UpdateText();
1624 : }
1625 0 : catch (uno::Exception &)
1626 : {
1627 : SAL_WARN( "starmath", "SmViewShell::Execute (SID_PASTEOBJECT): failed to get storage from input stream" );
1628 : }
1629 0 : }
1630 : }
1631 0 : break;
1632 :
1633 :
1634 : case SID_CUT:
1635 0 : if (pWin)
1636 0 : pWin->Cut();
1637 0 : break;
1638 :
1639 : case SID_COPY:
1640 0 : if (pWin)
1641 : {
1642 0 : if (pWin->IsAllSelected())
1643 : {
1644 : GetViewFrame()->GetDispatcher()->Execute(
1645 : SID_COPYOBJECT, SFX_CALLMODE_STANDARD,
1646 0 : new SfxVoidItem(SID_COPYOBJECT), 0L);
1647 : }
1648 : else
1649 0 : pWin->Copy();
1650 : }
1651 0 : break;
1652 :
1653 : case SID_PASTE:
1654 : {
1655 0 : bool bCallExec = 0 == pWin;
1656 0 : if( !bCallExec )
1657 : {
1658 : TransferableDataHelper aDataHelper(
1659 : TransferableDataHelper::CreateFromSystemClipboard(
1660 0 : GetEditWindow()) );
1661 :
1662 0 : if( aDataHelper.GetTransferable().is() &&
1663 0 : aDataHelper.HasFormat( FORMAT_STRING ))
1664 0 : pWin->Paste();
1665 : else
1666 0 : bCallExec = true;
1667 : }
1668 0 : if( bCallExec )
1669 : {
1670 : GetViewFrame()->GetDispatcher()->Execute(
1671 : SID_PASTEOBJECT, SFX_CALLMODE_STANDARD,
1672 0 : new SfxVoidItem(SID_PASTEOBJECT), 0L);
1673 : }
1674 : }
1675 0 : break;
1676 :
1677 : case SID_DELETE:
1678 0 : if (pWin)
1679 0 : pWin->Delete();
1680 0 : break;
1681 :
1682 : case SID_SELECT:
1683 0 : if (pWin)
1684 0 : pWin->SelectAll();
1685 0 : break;
1686 :
1687 : case SID_INSERTCOMMAND:
1688 : {
1689 : const SfxInt16Item& rItem =
1690 0 : (const SfxInt16Item&)rReq.GetArgs()->Get(SID_INSERTCOMMAND);
1691 :
1692 0 : if (pWin && (bInsertIntoEditWindow || !IsInlineEditEnabled()))
1693 0 : pWin->InsertCommand(rItem.GetValue());
1694 0 : if (IsInlineEditEnabled() && (GetDoc() && !bInsertIntoEditWindow)) {
1695 0 : GetDoc()->GetCursor().InsertCommand(rItem.GetValue());
1696 0 : GetGraphicWindow().GrabFocus();
1697 : }
1698 0 : break;
1699 : }
1700 :
1701 : case SID_INSERTCOMMANDTEXT:
1702 : {
1703 0 : const SfxStringItem& rItem = (const SfxStringItem&)rReq.GetArgs()->Get(SID_INSERTCOMMANDTEXT);
1704 :
1705 0 : if (pWin && (bInsertIntoEditWindow || !IsInlineEditEnabled()))
1706 : {
1707 0 : pWin->InsertText(rItem.GetValue());
1708 : }
1709 0 : if (IsInlineEditEnabled() && (GetDoc() && !bInsertIntoEditWindow))
1710 : {
1711 0 : GetDoc()->GetCursor().InsertCommandText(rItem.GetValue());
1712 0 : GetGraphicWindow().GrabFocus();
1713 : }
1714 0 : break;
1715 :
1716 : }
1717 :
1718 : case SID_INSERTSYMBOL:
1719 : {
1720 : const SfxStringItem& rItem =
1721 0 : (const SfxStringItem&)rReq.GetArgs()->Get(SID_INSERTSYMBOL);
1722 :
1723 0 : if (pWin && (bInsertIntoEditWindow || !IsInlineEditEnabled()))
1724 0 : pWin->InsertText(rItem.GetValue());
1725 0 : if (IsInlineEditEnabled() && (GetDoc() && !bInsertIntoEditWindow))
1726 0 : GetDoc()->GetCursor().InsertSpecial(rItem.GetValue());
1727 0 : break;
1728 : }
1729 :
1730 : case SID_IMPORT_FORMULA:
1731 : {
1732 0 : delete pImpl->pRequest;
1733 0 : pImpl->pRequest = new SfxRequest( rReq );
1734 0 : delete pImpl->pDocInserter;
1735 : pImpl->pDocInserter = new ::sfx2::DocumentInserter(
1736 0 : GetDoc()->GetFactory().GetFactoryName(), 0 );
1737 0 : pImpl->pDocInserter->StartExecuteModal( LINK( this, SmViewShell, DialogClosedHdl ) );
1738 0 : break;
1739 : }
1740 :
1741 : case SID_NEXTERR:
1742 0 : NextError();
1743 0 : if (pWin)
1744 0 : pWin->GrabFocus();
1745 0 : break;
1746 :
1747 : case SID_PREVERR:
1748 0 : PrevError();
1749 0 : if (pWin)
1750 0 : pWin->GrabFocus();
1751 0 : break;
1752 :
1753 : case SID_NEXTMARK:
1754 0 : if (pWin)
1755 : {
1756 0 : pWin->SelNextMark();
1757 0 : pWin->GrabFocus();
1758 : }
1759 0 : break;
1760 :
1761 : case SID_PREVMARK:
1762 0 : if (pWin)
1763 : {
1764 0 : pWin->SelPrevMark();
1765 0 : pWin->GrabFocus();
1766 : }
1767 0 : break;
1768 :
1769 : case SID_TEXTSTATUS:
1770 : {
1771 0 : if (rReq.GetArgs() != NULL)
1772 : {
1773 : const SfxStringItem& rItem =
1774 0 : (const SfxStringItem&)rReq.GetArgs()->Get(SID_TEXTSTATUS);
1775 :
1776 0 : SetStatusText(rItem.GetValue());
1777 : }
1778 :
1779 0 : break;
1780 : }
1781 :
1782 : case SID_GETEDITTEXT:
1783 0 : if (pWin)
1784 0 : if (!pWin->GetText().isEmpty()) GetDoc()->SetText( pWin->GetText() );
1785 0 : break;
1786 :
1787 : case SID_ATTR_ZOOM:
1788 : {
1789 4 : if ( !GetViewFrame()->GetFrame().IsInPlace() )
1790 : {
1791 4 : AbstractSvxZoomDialog *pDlg = 0;
1792 4 : const SfxItemSet *pSet = rReq.GetArgs();
1793 4 : if ( !pSet )
1794 : {
1795 0 : SfxItemSet aSet( GetDoc()->GetPool(), SID_ATTR_ZOOM, SID_ATTR_ZOOM);
1796 0 : aSet.Put( SvxZoomItem( SVX_ZOOM_PERCENT, aGraphic.GetZoom()));
1797 0 : SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1798 0 : if(pFact)
1799 : {
1800 0 : pDlg = pFact->CreateSvxZoomDialog(&GetViewFrame()->GetWindow(), aSet);
1801 : OSL_ENSURE(pDlg, "Dialogdiet fail!");
1802 0 : pDlg->SetLimits( MINZOOM, MAXZOOM );
1803 0 : if( pDlg->Execute() != RET_CANCEL )
1804 0 : pSet = pDlg->GetOutputItemSet();
1805 0 : }
1806 : }
1807 4 : if ( pSet )
1808 : {
1809 4 : const SvxZoomItem &rZoom = (const SvxZoomItem &)pSet->Get(SID_ATTR_ZOOM);
1810 4 : switch( rZoom.GetType() )
1811 : {
1812 : case SVX_ZOOM_PERCENT:
1813 3 : aGraphic.SetZoom((sal_uInt16)rZoom.GetValue ());
1814 3 : break;
1815 :
1816 : case SVX_ZOOM_OPTIMAL:
1817 1 : aGraphic.ZoomToFitInWindow();
1818 1 : break;
1819 :
1820 : case SVX_ZOOM_PAGEWIDTH:
1821 : case SVX_ZOOM_WHOLEPAGE:
1822 : {
1823 0 : const MapMode aMap( MAP_100TH_MM );
1824 0 : SfxPrinter *pPrinter = GetPrinter( true );
1825 0 : Point aPoint;
1826 0 : Rectangle OutputRect(aPoint, pPrinter->GetOutputSize());
1827 : Size OutputSize(pPrinter->LogicToPixel(Size(OutputRect.GetWidth(),
1828 0 : OutputRect.GetHeight()), aMap));
1829 0 : Size GraphicSize(pPrinter->LogicToPixel(GetDoc()->GetSize(), aMap));
1830 0 : sal_uInt16 nZ = (sal_uInt16) std::min((long)Fraction(OutputSize.Width() * 100L, GraphicSize.Width()),
1831 0 : (long)Fraction(OutputSize.Height() * 100L, GraphicSize.Height()));
1832 0 : aGraphic.SetZoom (nZ);
1833 0 : break;
1834 : }
1835 : default:
1836 0 : break;
1837 : }
1838 : }
1839 4 : delete pDlg;
1840 : }
1841 : }
1842 4 : break;
1843 :
1844 : case SID_ATTR_ZOOMSLIDER:
1845 : {
1846 0 : const SfxItemSet *pArgs = rReq.GetArgs();
1847 : const SfxPoolItem* pItem;
1848 :
1849 0 : if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState(SID_ATTR_ZOOMSLIDER, sal_True, &pItem ) )
1850 : {
1851 0 : const sal_uInt16 nCurrentZoom = ((const SvxZoomSliderItem *)pItem)->GetValue();
1852 0 : aGraphic.SetZoom( nCurrentZoom );
1853 : }
1854 : }
1855 0 : break;
1856 :
1857 : case SID_TOOLBOX:
1858 : {
1859 0 : GetViewFrame()->ToggleChildWindow( SmToolBoxWrapper::GetChildWindowId() );
1860 : }
1861 0 : break;
1862 :
1863 : case SID_ELEMENTSDOCKINGWINDOW:
1864 : {
1865 0 : GetViewFrame()->ToggleChildWindow( SmElementsDockingWindowWrapper::GetChildWindowId() );
1866 0 : GetViewFrame()->GetBindings().Invalidate( SID_ELEMENTSDOCKINGWINDOW );
1867 :
1868 0 : rReq.Ignore ();
1869 : }
1870 0 : break;
1871 :
1872 : case SID_SYMBOLS_CATALOGUE:
1873 : {
1874 :
1875 : // get device used to retrieve the FontList
1876 0 : SmDocShell *pDoc = GetDoc();
1877 0 : OutputDevice *pDev = pDoc->GetPrinter();
1878 0 : if (!pDev || pDev->GetDevFontCount() == 0)
1879 0 : pDev = &SM_MOD()->GetDefaultVirtualDev();
1880 : OSL_ENSURE (pDev, "device for font list missing" );
1881 :
1882 0 : SmModule *pp = SM_MOD();
1883 0 : SmSymbolDialog( NULL, pDev, pp->GetSymbolManager(), *this ).Execute();
1884 : }
1885 0 : break;
1886 : }
1887 8 : rReq.Done();
1888 8 : }
1889 :
1890 :
1891 160 : void SmViewShell::GetState(SfxItemSet &rSet)
1892 : {
1893 : SAL_INFO( "starmath", "starmath: SmViewShell::GetState" );
1894 :
1895 160 : SfxWhichIter aIter(rSet);
1896 :
1897 160 : SmEditWindow *pEditWin = GetEditWindow();
1898 350 : for (sal_uInt16 nWh = aIter.FirstWhich(); nWh != 0; nWh = aIter.NextWhich())
1899 : {
1900 190 : switch (nWh)
1901 : {
1902 : case SID_CUT:
1903 : case SID_COPY:
1904 : case SID_DELETE:
1905 26 : if (! pEditWin || ! pEditWin->IsSelected())
1906 26 : rSet.DisableItem(nWh);
1907 26 : break;
1908 :
1909 : case SID_PASTE:
1910 13 : if (pEditWin)
1911 : {
1912 : TransferableDataHelper aDataHelper(
1913 : TransferableDataHelper::CreateFromSystemClipboard(
1914 13 : pEditWin) );
1915 :
1916 13 : bPasteState = aDataHelper.GetTransferable().is() &&
1917 0 : ( aDataHelper.HasFormat( FORMAT_STRING ) ||
1918 0 : aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBEDDED_OBJ ) ||
1919 0 : (aDataHelper.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR )
1920 13 : && aDataHelper.HasFormat( SOT_FORMATSTR_ID_EMBED_SOURCE )));
1921 : }
1922 13 : if( !bPasteState )
1923 13 : rSet.DisableItem( nWh );
1924 13 : break;
1925 :
1926 : case SID_ATTR_ZOOM:
1927 46 : rSet.Put(SvxZoomItem( SVX_ZOOM_PERCENT, aGraphic.GetZoom()));
1928 : /* no break here */
1929 : case SID_ZOOMIN:
1930 : case SID_ZOOMOUT:
1931 : case SID_ZOOM_OPTIMAL:
1932 72 : if ( GetViewFrame()->GetFrame().IsInPlace() )
1933 0 : rSet.DisableItem( nWh );
1934 72 : break;
1935 :
1936 : case SID_ATTR_ZOOMSLIDER :
1937 : {
1938 20 : const sal_uInt16 nCurrentZoom = aGraphic.GetZoom();
1939 20 : SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM );
1940 20 : aZoomSliderItem.AddSnappingPoint( 100 );
1941 20 : rSet.Put( aZoomSliderItem );
1942 : }
1943 20 : break;
1944 :
1945 : case SID_NEXTERR:
1946 : case SID_PREVERR:
1947 : case SID_NEXTMARK:
1948 : case SID_PREVMARK:
1949 : case SID_DRAW:
1950 : case SID_SELECT:
1951 13 : if (! pEditWin || pEditWin->IsEmpty())
1952 11 : rSet.DisableItem(nWh);
1953 13 : break;
1954 :
1955 : case SID_TEXTSTATUS:
1956 : {
1957 20 : rSet.Put(SfxStringItem(nWh, aStatusText));
1958 : }
1959 20 : break;
1960 :
1961 : case SID_FORMULACURSOR:
1962 : {
1963 13 : SmModule *pp = SM_MOD();
1964 13 : rSet.Put(SfxBoolItem(nWh, pp->GetConfig()->IsShowFormulaCursor()));
1965 : }
1966 13 : break;
1967 : case SID_ELEMENTSDOCKINGWINDOW:
1968 : {
1969 0 : bool bState = false;
1970 : SfxChildWindow *pChildWnd = GetViewFrame()->
1971 0 : GetChildWindow( SmElementsDockingWindowWrapper::GetChildWindowId() );
1972 0 : if (pChildWnd && pChildWnd->GetWindow()->IsVisible())
1973 0 : bState = true;
1974 0 : rSet.Put(SfxBoolItem(SID_ELEMENTSDOCKINGWINDOW, bState));
1975 : }
1976 0 : break;
1977 : case SID_TOOLBOX:
1978 : {
1979 0 : bool bState = false;
1980 : SfxChildWindow *pChildWnd = GetViewFrame()->
1981 0 : GetChildWindow( SmToolBoxWrapper::GetChildWindowId() );
1982 0 : if (pChildWnd && pChildWnd->GetWindow()->IsVisible())
1983 0 : bState = true;
1984 0 : rSet.Put(SfxBoolItem(SID_TOOLBOX, bState));
1985 : }
1986 0 : break;
1987 :
1988 : }
1989 160 : }
1990 160 : }
1991 :
1992 :
1993 21 : SmViewShell::SmViewShell(SfxViewFrame *pFrame_, SfxViewShell *):
1994 : SfxViewShell(pFrame_, SFX_VIEW_HAS_PRINTOPTIONS | SFX_VIEW_CAN_PRINT),
1995 21 : pImpl( new SmViewShell_Impl ),
1996 : aGraphic(this),
1997 21 : aGraphicController(aGraphic, SID_GAPHIC_SM, pFrame_->GetBindings())
1998 63 : , bInsertIntoEditWindow(false)
1999 : {
2000 : SAL_INFO( "starmath", "starmath: SmViewShell::SmViewShell" );
2001 :
2002 21 : SetStatusText(OUString());
2003 21 : SetWindow(&aGraphic);
2004 21 : SfxShell::SetName(OUString("SmView"));
2005 21 : SfxShell::SetUndoManager( &GetDoc()->GetEditEngine().GetUndoManager() );
2006 21 : SetHelpId( HID_SMA_VIEWSHELL_DOCUMENT );
2007 21 : }
2008 :
2009 :
2010 51 : SmViewShell::~SmViewShell()
2011 : {
2012 : SAL_INFO( "starmath", "starmath: SmViewShell::~SmViewShell" );
2013 :
2014 : //!! this view shell is not active anymore !!
2015 : // Thus 'SmGetActiveView' will give a 0 pointer.
2016 : // Thus we need to supply this view as argument
2017 17 : SmEditWindow *pEditWin = GetEditWindow();
2018 17 : if (pEditWin)
2019 0 : pEditWin->DeleteEditView( *this );
2020 17 : delete pImpl;
2021 34 : }
2022 :
2023 17 : void SmViewShell::Deactivate( sal_Bool bIsMDIActivate )
2024 : {
2025 : SAL_INFO( "starmath", "starmath: SmViewShell::Deactivate" );
2026 :
2027 17 : SmEditWindow *pEdit = GetEditWindow();
2028 17 : if ( pEdit )
2029 0 : pEdit->Flush();
2030 :
2031 17 : SfxViewShell::Deactivate( bIsMDIActivate );
2032 17 : }
2033 :
2034 :
2035 17 : void SmViewShell::Activate( sal_Bool bIsMDIActivate )
2036 : {
2037 : SAL_INFO( "starmath", "starmath: SmViewShell::Activate" );
2038 :
2039 17 : SfxViewShell::Activate( bIsMDIActivate );
2040 :
2041 17 : SmEditWindow *pEdit = GetEditWindow();
2042 17 : if ( pEdit )
2043 : {
2044 : //! Since there is no way to be informed if a "drag and drop"
2045 : //! event has taken place, we call SetText here in order to
2046 : //! syncronize the GraphicWindow display with the text in the
2047 : //! EditEngine.
2048 17 : SmDocShell *pDoc = GetDoc();
2049 17 : pDoc->SetText( pDoc->GetEditEngine().GetText( LINEEND_LF ) );
2050 :
2051 17 : if ( bIsMDIActivate )
2052 17 : pEdit->GrabFocus();
2053 : }
2054 17 : }
2055 :
2056 0 : IMPL_LINK( SmViewShell, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg )
2057 : {
2058 : OSL_ENSURE( _pFileDlg, "SmViewShell::DialogClosedHdl(): no file dialog" );
2059 : OSL_ENSURE( pImpl->pDocInserter, "ScDocShell::DialogClosedHdl(): no document inserter" );
2060 :
2061 0 : if ( ERRCODE_NONE == _pFileDlg->GetError() )
2062 : {
2063 0 : SfxMedium* pMedium = pImpl->pDocInserter->CreateMedium();
2064 :
2065 0 : if ( pMedium != NULL )
2066 : {
2067 0 : if ( pMedium->IsStorage() )
2068 0 : Insert( *pMedium );
2069 : else
2070 0 : InsertFrom( *pMedium );
2071 0 : delete pMedium;
2072 :
2073 0 : SmDocShell* pDoc = GetDoc();
2074 0 : pDoc->UpdateText();
2075 0 : pDoc->ArrangeFormula();
2076 0 : pDoc->Repaint();
2077 : // adjust window, repaint, increment ModifyCount,...
2078 0 : GetViewFrame()->GetBindings().Invalidate(SID_GAPHIC_SM);
2079 : }
2080 : }
2081 :
2082 0 : pImpl->pRequest->SetReturnValue( SfxBoolItem( pImpl->pRequest->GetSlot(), true ) );
2083 0 : pImpl->pRequest->Done();
2084 0 : return 0;
2085 : }
2086 :
2087 273 : void SmViewShell::Notify( SfxBroadcaster& , const SfxHint& rHint )
2088 : {
2089 273 : if ( rHint.IsA(TYPE(SfxSimpleHint)) )
2090 : {
2091 133 : switch( ( (SfxSimpleHint&) rHint ).GetId() )
2092 : {
2093 : case SFX_HINT_MODECHANGED:
2094 : case SFX_HINT_DOCCHANGED:
2095 85 : GetViewFrame()->GetBindings().InvalidateAll(false);
2096 85 : break;
2097 : default:
2098 48 : break;
2099 : }
2100 : }
2101 273 : }
2102 :
2103 181 : bool SmViewShell::IsInlineEditEnabled() const
2104 : {
2105 181 : return pImpl->aOpts.IsExperimentalMode();
2106 21 : }
2107 :
2108 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
