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