LCOV - code coverage report
Current view: top level - libreoffice/sd/source/ui/view - drviews9.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 408 0.0 %
Date: 2012-12-27 Functions: 0 4 0.0 %
Legend: Lines: hit not hit

          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             : 
      21             : #include "DrawViewShell.hxx"
      22             : #include <vcl/wrkwin.hxx>
      23             : #include <svx/xgrad.hxx>
      24             : #include <svx/svdpagv.hxx>
      25             : #include <svx/xlnwtit.hxx>
      26             : #include <svx/xlndsit.hxx>
      27             : #include <svx/xflhtit.hxx>
      28             : #include <svx/xflgrit.hxx>
      29             : #include <svx/xlnclit.hxx>
      30             : #include <svx/xflclit.hxx>
      31             : #include <sfx2/bindings.hxx>
      32             : 
      33             : #include <sfx2/dispatch.hxx>
      34             : #include <svl/intitem.hxx>
      35             : #include <sfx2/app.hxx>
      36             : #include <sfx2/request.hxx>
      37             : #include <svl/stritem.hxx>
      38             : #include <svx/svxids.hrc>
      39             : #include <svx/xtable.hxx>
      40             : #include <svx/gallery.hxx>
      41             : #include <vcl/graph.hxx>
      42             : #include <svx/svdograf.hxx>
      43             : #include <svx/svdoole2.hxx>
      44             : #include <sot/storage.hxx>
      45             : #include <svl/whiter.hxx>
      46             : #include <basic/sbstar.hxx>
      47             : 
      48             : #include <sfx2/viewfrm.hxx>
      49             : 
      50             : 
      51             : #include "app.hrc"
      52             : #include "strings.hrc"
      53             : #include "Window.hxx"
      54             : #include "drawdoc.hxx"
      55             : #include "drawview.hxx"
      56             : #include "DrawDocShell.hxx"
      57             : #include "sdresid.hxx"
      58             : #include "fupoor.hxx"
      59             : 
      60             : namespace sd {
      61             : 
      62             : /*************************************************************************
      63             : |*
      64             : |* SfxRequests fuer Gallery bearbeiten
      65             : |*
      66             : \************************************************************************/
      67             : 
      68           0 : void DrawViewShell::ExecGallery(SfxRequest& rReq)
      69             : {
      70             :     // waehrend einer Diashow wird nichts ausgefuehrt!
      71           0 :     if(HasCurrentFunction(SID_PRESENTATION))
      72           0 :         return;
      73             : 
      74           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
      75             : 
      76           0 :     if ( pArgs )
      77             :     {
      78           0 :         const sal_uInt32        nFormats = ( (SfxUInt32Item&) pArgs->Get( SID_GALLERY_FORMATS ) ).GetValue();
      79           0 :         GalleryExplorer*    pGal = SVX_GALLERY();
      80             : 
      81           0 :         if ( pGal )
      82             :         {
      83           0 :             GetDocSh()->SetWaitCursor( sal_True );
      84             : 
      85             :             // Graphik einfuegen
      86           0 :             if (nFormats & SGA_FORMAT_GRAPHIC)
      87             :             {
      88           0 :                 Graphic aGraphic = pGal->GetGraphic();
      89             : 
      90             :                 // Ggf. Groesse reduzieren
      91           0 :                 Window aWindow (GetActiveWindow());
      92           0 :                 aWindow.SetMapMode(aGraphic.GetPrefMapMode());
      93           0 :                 Size aSizePix = aWindow.LogicToPixel(aGraphic.GetPrefSize());
      94           0 :                 aWindow.SetMapMode( MapMode(MAP_100TH_MM) );
      95           0 :                 Size aSize = aWindow.PixelToLogic(aSizePix);
      96             : 
      97             :                 // Groesse ggf. auf Seitengroesse begrenzen
      98           0 :                 SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage();
      99           0 :                 Size aPageSize = pPage->GetSize();
     100           0 :                 aPageSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder();
     101           0 :                 aPageSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder();
     102             : 
     103             : 
     104             :                 // Falls Grafik zu gross, wird die Grafik
     105             :                 // in die Seite eingepasst
     106           0 :                 if ( ( ( aSize.Height() > aPageSize.Height() ) || ( aSize.Width()   > aPageSize.Width() ) ) &&
     107           0 :                     aSize.Height() && aPageSize.Height() )
     108             :                 {
     109           0 :                     float fGrfWH =  (float)aSize.Width() /
     110           0 :                                     (float)aSize.Height();
     111           0 :                     float fWinWH =  (float)aPageSize.Width() /
     112           0 :                                     (float)aPageSize.Height();
     113             : 
     114             :                     // Grafik an Pagesize anpassen (skaliert)
     115           0 :                     if ((fGrfWH != 0.F) && (fGrfWH < fWinWH))
     116             :                     {
     117           0 :                         aSize.Width() = (long)(aPageSize.Height() * fGrfWH);
     118           0 :                         aSize.Height()= aPageSize.Height();
     119             :                     }
     120             :                     else
     121             :                     {
     122           0 :                         aSize.Width() = aPageSize.Width();
     123           0 :                         aSize.Height()= (long)(aPageSize.Width() / fGrfWH);
     124             :                     }
     125             :                 }
     126             : 
     127             : 
     128             :                 // Ausgaberechteck fuer Grafik setzen
     129           0 :                 Point aPnt ((aPageSize.Width()  - aSize.Width())  / 2,
     130           0 :                             (aPageSize.Height() - aSize.Height()) / 2);
     131           0 :                 aPnt += Point(pPage->GetLftBorder(), pPage->GetUppBorder());
     132           0 :                 Rectangle aRect (aPnt, aSize);
     133             : 
     134           0 :                 SdrGrafObj* pGrafObj = NULL;
     135             : 
     136           0 :                 sal_Bool bInsertNewObject = sal_True;
     137             : 
     138           0 :                 if ( mpDrawView->AreObjectsMarked() )
     139             :                 {
     140             :                     /******************************************************
     141             :                     * Ist ein leeres Graphik-Objekt vorhanden?
     142             :                     ******************************************************/
     143           0 :                     const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
     144             : 
     145           0 :                     if (rMarkList.GetMarkCount() == 1)
     146             :                     {
     147           0 :                         SdrMark* pMark = rMarkList.GetMark(0);
     148           0 :                         SdrObject* pObj = pMark->GetMarkedSdrObj();
     149             : 
     150           0 :                         if (pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF)
     151             :                         {
     152           0 :                             pGrafObj = (SdrGrafObj*) pObj;
     153             : 
     154           0 :                             if( pGrafObj->IsEmptyPresObj() )
     155             :                             {
     156             :                                 /******************************************
     157             :                                 * Das leere Graphik-Objekt bekommt eine neue
     158             :                                 * Graphik
     159             :                                 ******************************************/
     160           0 :                                 bInsertNewObject = sal_False;
     161             : 
     162           0 :                                 SdrGrafObj* pNewGrafObj = (SdrGrafObj*) pGrafObj->Clone();
     163           0 :                                 pNewGrafObj->SetEmptyPresObj(sal_False);
     164           0 :                                 pNewGrafObj->SetOutlinerParaObject(NULL);
     165           0 :                                 pNewGrafObj->SetGraphic(aGraphic);
     166             : 
     167           0 :                                 String aStr(mpDrawView->GetDescriptionOfMarkedObjects());
     168           0 :                                 aStr += sal_Unicode(' ');
     169           0 :                                 aStr += String(SdResId(STR_UNDO_REPLACE));
     170           0 :                                 mpDrawView->BegUndo(aStr);
     171           0 :                                 SdrPageView* pPV = mpDrawView->GetSdrPageView();
     172           0 :                                 mpDrawView->ReplaceObjectAtView(pGrafObj, *pPV, pNewGrafObj);
     173           0 :                                 mpDrawView->EndUndo();
     174             :                             }
     175             :                         }
     176             :                     }
     177             :                 }
     178             : 
     179             : 
     180           0 :                 if( bInsertNewObject )
     181             :                 {
     182           0 :                     pGrafObj = new SdrGrafObj(aGraphic, aRect);
     183           0 :                     SdrPageView* pPV = mpDrawView->GetSdrPageView();
     184           0 :                     mpDrawView->InsertObjectAtView(pGrafObj, *pPV, SDRINSERT_SETDEFLAYER);
     185             :                 }
     186             : 
     187             :                 // Soll nur ein Link benutzt werden?
     188           0 :                 if( pGrafObj && pGal->IsLinkage() )
     189           0 :                     pGrafObj->SetGraphicLink( pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ), pGal->GetFilterName() );
     190             :             }
     191             :             // insert sound
     192           0 :             else if( nFormats & SGA_FORMAT_SOUND )
     193             :             {
     194           0 :                 const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ) );
     195           0 :                    GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON, &aMediaURLItem, 0L );
     196             :             }
     197             : 
     198           0 :             GetDocSh()->SetWaitCursor( sal_False );
     199             :         }
     200             :     }
     201             : }
     202             : 
     203             : 
     204             : /*************************************************************************
     205             : |*
     206             : |* Statuswerte fuer Gallery zurueckgeben
     207             : |*
     208             : \************************************************************************/
     209             : 
     210           0 : void DrawViewShell::GetGalleryState(SfxItemSet& )
     211             : {
     212           0 : }
     213             : 
     214             : /*************************************************************************
     215             : |*
     216             : |* Makros fuer die Attributeinstellungen bearbeiten
     217             : |*
     218             : \************************************************************************/
     219             : 
     220             : //
     221             : // die vorgehensweise fuer die attributaenderung ist praktisch ueberall identisch
     222             : // 1. bisherige attribute auslesen
     223             : // 2. parameter aus dem basic-set auslesen
     224             : // 3. gewaehltes item aus dem attribut-set loeschen
     225             : // 4. neues attribut-item erzeugen
     226             : // 5. item in den set eintragen
     227             : //
     228           0 : void DrawViewShell::AttrExec (SfxRequest &rReq)
     229             : {
     230             :     // waehrend einer Diashow wird nichts ausgefuehrt!
     231           0 :     if(HasCurrentFunction(SID_PRESENTATION))
     232           0 :         return;
     233             : 
     234           0 :     CheckLineTo (rReq);
     235             : 
     236           0 :     SfxBindings&    rBindings = GetViewFrame()->GetBindings();
     237           0 :     SfxItemSet*     pAttr = new SfxItemSet ( GetDoc()->GetPool() );
     238             : 
     239           0 :     GetView()->GetAttributes( *pAttr );
     240           0 :     const SfxItemSet* pArgs = rReq.GetArgs();
     241             : 
     242           0 :     switch (rReq.GetSlot ())
     243             :     {
     244             :         // neuen fuellstil setzen
     245             :         case SID_SETFILLSTYLE :
     246           0 :             if (pArgs)
     247           0 :                 if (pArgs->Count () == 1)
     248             :                 {
     249           0 :                     SFX_REQUEST_ARG (rReq, pFillStyle, SfxUInt32Item, ID_VAL_STYLE, sal_False);
     250           0 :                     if (CHECK_RANGE (XFILL_NONE, (sal_Int32)pFillStyle->GetValue (), XFILL_BITMAP))
     251             :                     {
     252           0 :                         pAttr->ClearItem (XATTR_FILLSTYLE);
     253           0 :                         pAttr->Put (XFillStyleItem ((XFillStyle) pFillStyle->GetValue ()), XATTR_FILLSTYLE);
     254           0 :                         rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     255             :                     }
     256             : #ifndef DISABLE_SCRIPTING
     257           0 :                     else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
     258             : #endif
     259           0 :                     break;
     260             :                 }
     261             : #ifndef DISABLE_SCRIPTING
     262           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     263             : #endif
     264           0 :             break;
     265             : 
     266             :         // linienstil neu bestimmen
     267             :         case SID_SETLINESTYLE :
     268           0 :             if (pArgs)
     269           0 :                 if (pArgs->Count () == 1)
     270             :                 {
     271           0 :                     SFX_REQUEST_ARG (rReq, pLineStyle, SfxUInt32Item, ID_VAL_STYLE, sal_False);
     272           0 :                     if (CHECK_RANGE (XLINE_NONE, (sal_Int32)pLineStyle->GetValue (), XLINE_DASH))
     273             :                     {
     274           0 :                         pAttr->ClearItem (XATTR_LINESTYLE);
     275           0 :                         pAttr->Put (XLineStyleItem ((XLineStyle) pLineStyle->GetValue ()), XATTR_LINESTYLE);
     276           0 :                         rBindings.Invalidate (SID_ATTR_LINE_STYLE);
     277             :                     }
     278             : #ifndef DISABLE_SCRIPTING
     279           0 :                     else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
     280             : #endif
     281           0 :                     break;
     282             :                 }
     283             : #ifndef DISABLE_SCRIPTING
     284           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     285             : #endif
     286           0 :             break;
     287             : 
     288             :         // linienbreite setzen
     289             :         case SID_SETLINEWIDTH :
     290           0 :             if (pArgs)
     291           0 :                 if (pArgs->Count () == 1)
     292             :                 {
     293           0 :                     SFX_REQUEST_ARG (rReq, pLineWidth, SfxUInt32Item, ID_VAL_WIDTH, sal_False);
     294           0 :                     pAttr->ClearItem (XATTR_LINEWIDTH);
     295           0 :                     pAttr->Put (XLineWidthItem (pLineWidth->GetValue ()), XATTR_LINEWIDTH);
     296           0 :                     rBindings.Invalidate (SID_ATTR_LINE_WIDTH);
     297           0 :                     break;
     298             :                 }
     299             : #ifndef DISABLE_SCRIPTING
     300           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     301             : #endif
     302           0 :             break;
     303             : 
     304             :         case SID_SETFILLCOLOR :
     305           0 :             if (pArgs)
     306           0 :                 if (pArgs->Count () == 3)
     307             :                 {
     308           0 :                     SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, sal_False);
     309           0 :                     SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, sal_False);
     310           0 :                     SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, sal_False);
     311             : 
     312           0 :                     pAttr->ClearItem (XATTR_FILLCOLOR);
     313           0 :                     pAttr->ClearItem (XATTR_FILLSTYLE);
     314           0 :                     pAttr->Put (XFillColorItem (-1, Color ((sal_uInt8) pRed->GetValue (),
     315           0 :                                                            (sal_uInt8) pGreen->GetValue (),
     316           0 :                                                            (sal_uInt8) pBlue->GetValue ())),
     317           0 :                                 XATTR_FILLCOLOR);
     318           0 :                     pAttr->Put (XFillStyleItem (XFILL_SOLID), XATTR_FILLSTYLE);
     319           0 :                     rBindings.Invalidate (SID_ATTR_FILL_COLOR);
     320           0 :                     rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     321           0 :                     break;
     322             :                 }
     323             : #ifndef DISABLE_SCRIPTING
     324           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     325             : #endif
     326           0 :             break;
     327             : 
     328             :         case SID_SETLINECOLOR :
     329           0 :             if (pArgs)
     330           0 :                 if (pArgs->Count () == 3)
     331             :                 {
     332           0 :                     SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, sal_False);
     333           0 :                     SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, sal_False);
     334           0 :                     SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, sal_False);
     335             : 
     336           0 :                     pAttr->ClearItem (XATTR_LINECOLOR);
     337           0 :                     pAttr->Put (XLineColorItem (-1, Color ((sal_uInt8) pRed->GetValue (),
     338           0 :                                                            (sal_uInt8) pGreen->GetValue (),
     339           0 :                                                            (sal_uInt8) pBlue->GetValue ())),
     340           0 :                                 XATTR_LINECOLOR);
     341           0 :                     rBindings.Invalidate (SID_ATTR_LINE_COLOR);
     342           0 :                     break;
     343             :                 }
     344             : #ifndef DISABLE_SCRIPTING
     345           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     346             : #endif
     347           0 :             break;
     348             : 
     349             :         case SID_SETGRADSTARTCOLOR :
     350             :         case SID_SETGRADENDCOLOR :
     351           0 :             if (pArgs)
     352           0 :                 if (pArgs->Count () == 4)
     353             :                 {
     354           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     355           0 :                     SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, sal_False);
     356           0 :                     SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, sal_False);
     357           0 :                     SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, sal_False);
     358             : 
     359           0 :                     XGradientListRef pGradientList = GetDoc()->GetGradientList ();
     360           0 :                     long          nCounts        = pGradientList->Count ();
     361           0 :                     Color         aColor ((sal_uInt8) pRed->GetValue (),
     362           0 :                                           (sal_uInt8) pGreen->GetValue (),
     363           0 :                                           (sal_uInt8) pBlue->GetValue ());
     364             :                     long i;
     365             : 
     366           0 :                     pAttr->ClearItem (XATTR_FILLGRADIENT);
     367           0 :                     pAttr->ClearItem (XATTR_FILLSTYLE);
     368             : 
     369           0 :                     for ( i = 0; i < nCounts; i ++)
     370             :                     {
     371           0 :                         XGradientEntry *pEntry = pGradientList->GetGradient (i);
     372             : 
     373           0 :                         if (pEntry->GetName () == pName->GetValue ())
     374             :                         {
     375           0 :                             XGradient &rGradient = pEntry->GetGradient ();
     376             : 
     377           0 :                             if (rReq.GetSlot () == SID_SETGRADSTARTCOLOR) rGradient.SetStartColor (aColor);
     378           0 :                             else rGradient.SetEndColor (aColor);
     379             : 
     380           0 :                             pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE);
     381           0 :                             pAttr->Put (XFillGradientItem (pName->GetValue (), rGradient), XATTR_FILLGRADIENT);
     382           0 :                             break;
     383             :                         }
     384             :                     }
     385             : 
     386           0 :                     if (i >= nCounts)
     387             :                     {
     388           0 :                         Color aBlack (0, 0, 0);
     389           0 :                         XGradient aGradient ((rReq.GetSlot () == SID_SETGRADSTARTCOLOR)
     390             :                                                  ? aColor
     391             :                                                  : aBlack,
     392           0 :                                              (rReq.GetSlot () == SID_SETGRADENDCOLOR)
     393             :                                                  ? aColor
     394           0 :                                                  : aBlack);
     395             : 
     396           0 :                         GetDoc()->GetGradientList ()->Insert (new XGradientEntry (aGradient, pName->GetValue ()));
     397             : 
     398           0 :                         pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE);
     399           0 :                         pAttr->Put (XFillGradientItem (pName->GetValue (), aGradient), XATTR_FILLGRADIENT);
     400             :                     }
     401             : 
     402           0 :                     rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     403           0 :                     rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
     404           0 :                     break;
     405             :                 }
     406             : #ifndef DISABLE_SCRIPTING
     407           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     408             : #endif
     409           0 :             break;
     410             : 
     411             :         case SID_SETHATCHCOLOR :
     412           0 :             if (pArgs)
     413           0 :                 if (pArgs->Count () == 4)
     414             :                 {
     415           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     416           0 :                     SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, sal_False);
     417           0 :                     SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, sal_False);
     418           0 :                     SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, sal_False);
     419             : 
     420           0 :                     XHatchListRef pHatchList = GetDoc()->GetHatchList ();
     421           0 :                     long       nCounts     = pHatchList->Count ();
     422           0 :                     Color      aColor ((sal_uInt8) pRed->GetValue (),
     423           0 :                                        (sal_uInt8) pGreen->GetValue (),
     424           0 :                                        (sal_uInt8) pBlue->GetValue ());
     425             :                     long i;
     426             : 
     427           0 :                     pAttr->ClearItem (XATTR_FILLHATCH);
     428           0 :                     pAttr->ClearItem (XATTR_FILLSTYLE);
     429             : 
     430           0 :                     for ( i = 0; i < nCounts; i ++)
     431             :                     {
     432           0 :                         XHatchEntry *pEntry = pHatchList->GetHatch (i);
     433             : 
     434           0 :                         if (pEntry->GetName () == pName->GetValue ())
     435             :                         {
     436           0 :                             XHatch &rHatch = pEntry->GetHatch ();
     437             : 
     438           0 :                             rHatch.SetColor (aColor);
     439             : 
     440           0 :                             pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE);
     441           0 :                             pAttr->Put (XFillHatchItem (pName->GetValue (), rHatch), XATTR_FILLHATCH);
     442           0 :                             break;
     443             :                         }
     444             :                     }
     445             : 
     446           0 :                     if (i >= nCounts)
     447             :                     {
     448           0 :                         XHatch aHatch (aColor);
     449             : 
     450           0 :                         GetDoc()->GetHatchList ()->Insert (new XHatchEntry (aHatch, pName->GetValue ()));
     451             : 
     452           0 :                         pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE);
     453           0 :                         pAttr->Put (XFillHatchItem (pName->GetValue (), aHatch), XATTR_FILLHATCH);
     454             :                     }
     455             : 
     456           0 :                     rBindings.Invalidate (SID_ATTR_FILL_HATCH);
     457           0 :                     rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     458           0 :                     break;
     459             :                 }
     460             : #ifndef DISABLE_SCRIPTING
     461           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     462             : #endif
     463           0 :             break;
     464             : 
     465             :         // einstellungen fuer liniendash
     466             :         case SID_DASH :
     467           0 :             if (pArgs)
     468           0 :                 if (pArgs->Count () == 7)
     469             :                 {
     470           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     471           0 :                     SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, sal_False);
     472           0 :                     SFX_REQUEST_ARG (rReq, pDots, SfxUInt32Item, ID_VAL_DOTS, sal_False);
     473           0 :                     SFX_REQUEST_ARG (rReq, pDotLen, SfxUInt32Item, ID_VAL_DOTLEN, sal_False);
     474           0 :                     SFX_REQUEST_ARG (rReq, pDashes, SfxUInt32Item, ID_VAL_DASHES, sal_False);
     475           0 :                     SFX_REQUEST_ARG (rReq, pDashLen, SfxUInt32Item, ID_VAL_DASHLEN, sal_False);
     476           0 :                     SFX_REQUEST_ARG (rReq, pDistance, SfxUInt32Item, ID_VAL_DISTANCE, sal_False);
     477             : 
     478           0 :                     if (CHECK_RANGE (XDASH_RECT, (sal_Int32)pStyle->GetValue (), XDASH_ROUNDRELATIVE))
     479             :                     {
     480           0 :                         XDash aNewDash ((XDashStyle) pStyle->GetValue (), (short) pDots->GetValue (), pDotLen->GetValue (),
     481           0 :                                         (short) pDashes->GetValue (), pDashLen->GetValue (), pDistance->GetValue ());
     482             : 
     483           0 :                         pAttr->ClearItem (XATTR_LINEDASH);
     484           0 :                         pAttr->ClearItem (XATTR_LINESTYLE);
     485             : 
     486           0 :                         XDashListRef pDashList = GetDoc()->GetDashList();
     487           0 :                         long       nCounts    = pDashList->Count ();
     488           0 :                         XDashEntry *pEntry    = new XDashEntry (aNewDash, pName->GetValue ());
     489             :                         long i;
     490             : 
     491           0 :                         for ( i = 0; i < nCounts; i++ )
     492           0 :                             if (pDashList->GetDash (i)->GetName () == pName->GetValue ())
     493           0 :                                 break;
     494             : 
     495           0 :                         if (i < nCounts)
     496           0 :                             pDashList->Replace (pEntry, i);
     497             :                         else
     498           0 :                             pDashList->Insert (pEntry);
     499             : 
     500           0 :                         pAttr->Put (XLineDashItem (pName->GetValue (), aNewDash), XATTR_LINEDASH);
     501           0 :                         pAttr->Put (XLineStyleItem (XLINE_DASH), XATTR_LINESTYLE);
     502           0 :                         rBindings.Invalidate (SID_ATTR_LINE_DASH);
     503           0 :                         rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     504             :                     }
     505             : #ifndef DISABLE_SCRIPTING
     506           0 :                     else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
     507             : #endif
     508           0 :                     break;
     509             :                 }
     510             : #ifndef DISABLE_SCRIPTING
     511           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     512             : #endif
     513           0 :             break;
     514             : 
     515             :         // einstellungen fuer farbverlauf
     516             :         case SID_GRADIENT :
     517           0 :             if (pArgs)
     518           0 :                 if (pArgs->Count () == 8)
     519             :                 {
     520           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     521           0 :                     SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, sal_False);
     522           0 :                     SFX_REQUEST_ARG (rReq, pAngle, SfxUInt32Item, ID_VAL_ANGLE, sal_False);
     523           0 :                     SFX_REQUEST_ARG (rReq, pBorder, SfxUInt32Item, ID_VAL_BORDER, sal_False);
     524           0 :                     SFX_REQUEST_ARG (rReq, pCenterX, SfxUInt32Item, ID_VAL_CENTER_X, sal_False);
     525           0 :                     SFX_REQUEST_ARG (rReq, pCenterY, SfxUInt32Item, ID_VAL_CENTER_Y, sal_False);
     526           0 :                     SFX_REQUEST_ARG (rReq, pStart, SfxUInt32Item, ID_VAL_STARTINTENS, sal_False);
     527           0 :                     SFX_REQUEST_ARG (rReq, pEnd, SfxUInt32Item, ID_VAL_ENDINTENS, sal_False);
     528             : 
     529           0 :                     if (CHECK_RANGE (XGRAD_LINEAR, (sal_Int32)pStyle->GetValue (), XGRAD_RECT) &&
     530           0 :                         CHECK_RANGE (0, (sal_Int32)pAngle->GetValue (), 360) &&
     531           0 :                         CHECK_RANGE (0, (sal_Int32)pBorder->GetValue (), 100) &&
     532           0 :                         CHECK_RANGE (0, (sal_Int32)pCenterX->GetValue (), 100) &&
     533           0 :                         CHECK_RANGE (0, (sal_Int32)pCenterY->GetValue (), 100) &&
     534           0 :                         CHECK_RANGE (0, (sal_Int32)pStart->GetValue (), 100) &&
     535           0 :                         CHECK_RANGE (0, (sal_Int32)pEnd->GetValue (), 100))
     536             :                     {
     537           0 :                         pAttr->ClearItem (XATTR_FILLGRADIENT);
     538           0 :                         pAttr->ClearItem (XATTR_FILLSTYLE);
     539             : 
     540           0 :                         XGradientListRef pGradientList = GetDoc()->GetGradientList ();
     541           0 :                         long           nCounts        = pGradientList->Count ();
     542             :                         long i;
     543             : 
     544           0 :                         for ( i = 0; i < nCounts; i++ )
     545             :                         {
     546           0 :                             XGradientEntry *pEntry = pGradientList->GetGradient (i);
     547             : 
     548           0 :                             if (pEntry->GetName () == pName->GetValue ())
     549             :                             {
     550           0 :                                 XGradient &rGradient = pEntry->GetGradient ();
     551             : 
     552           0 :                                 rGradient.SetGradientStyle ((XGradientStyle) pStyle->GetValue ());
     553           0 :                                 rGradient.SetAngle (pAngle->GetValue () * 10);
     554           0 :                                 rGradient.SetBorder ((short) pBorder->GetValue ());
     555           0 :                                 rGradient.SetXOffset ((short) pCenterX->GetValue ());
     556           0 :                                 rGradient.SetYOffset ((short) pCenterY->GetValue ());
     557           0 :                                 rGradient.SetStartIntens ((short) pStart->GetValue ());
     558           0 :                                 rGradient.SetEndIntens ((short) pEnd->GetValue ());
     559             : 
     560           0 :                                 pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE);
     561           0 :                                 pAttr->Put (XFillGradientItem (pName->GetValue (), rGradient), XATTR_FILLGRADIENT);
     562           0 :                                 break;
     563             :                             }
     564             :                         }
     565             : 
     566           0 :                         if (i >= nCounts)
     567             :                         {
     568           0 :                             Color aBlack (0, 0, 0);
     569           0 :                             XGradient aGradient (aBlack, aBlack, (XGradientStyle) pStyle->GetValue (),
     570           0 :                                                  pAngle->GetValue () * 10, (short) pCenterX->GetValue (),
     571           0 :                                                  (short) pCenterY->GetValue (), (short) pBorder->GetValue (),
     572           0 :                                                  (short) pStart->GetValue (), (short) pEnd->GetValue ());
     573             : 
     574           0 :                             pGradientList->Insert (new XGradientEntry (aGradient, pName->GetValue ()));
     575           0 :                             pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE);
     576           0 :                             pAttr->Put (XFillGradientItem (pName->GetValue (), aGradient), XATTR_FILLGRADIENT);
     577             :                         }
     578             : 
     579           0 :                         rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
     580           0 :                         rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     581             :                     }
     582             : #ifndef DISABLE_SCRIPTING
     583           0 :                     else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
     584             : #endif
     585           0 :                     break;
     586             :                 }
     587             : #ifndef DISABLE_SCRIPTING
     588           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     589             : #endif
     590           0 :             break;
     591             : 
     592             :         // einstellungen fuer schraffur
     593             :         case SID_HATCH :
     594           0 :             if (pArgs)
     595           0 :                 if (pArgs->Count () == 4)
     596             :                 {
     597           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     598           0 :                     SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, sal_False);
     599           0 :                     SFX_REQUEST_ARG (rReq, pDistance, SfxUInt32Item, ID_VAL_DISTANCE, sal_False);
     600           0 :                     SFX_REQUEST_ARG (rReq, pAngle, SfxUInt32Item, ID_VAL_ANGLE, sal_False);
     601             : 
     602           0 :                     if (CHECK_RANGE (XHATCH_SINGLE, (sal_Int32)pStyle->GetValue (), XHATCH_TRIPLE) &&
     603           0 :                         CHECK_RANGE (0, (sal_Int32)pAngle->GetValue (), 360))
     604             :                     {
     605           0 :                         pAttr->ClearItem (XATTR_FILLHATCH);
     606           0 :                         pAttr->ClearItem (XATTR_FILLSTYLE);
     607             : 
     608           0 :                         XHatchListRef pHatchList = GetDoc()->GetHatchList ();
     609           0 :                         long       nCounts     = pHatchList->Count ();
     610             :                         long i;
     611             : 
     612           0 :                         for ( i = 0; i < nCounts; i++ )
     613             :                         {
     614           0 :                             XHatchEntry *pEntry = pHatchList->GetHatch (i);
     615             : 
     616           0 :                             if (pEntry->GetName () == pName->GetValue ())
     617             :                             {
     618           0 :                                 XHatch &rHatch = pEntry->GetHatch ();
     619             : 
     620           0 :                                 rHatch.SetHatchStyle ((XHatchStyle) pStyle->GetValue ());
     621           0 :                                 rHatch.SetDistance (pDistance->GetValue ());
     622           0 :                                 rHatch.SetAngle (pAngle->GetValue () * 10);
     623             : 
     624           0 :                                 pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE);
     625           0 :                                 pAttr->Put (XFillHatchItem (pName->GetValue (), rHatch), XATTR_FILLHATCH);
     626           0 :                                 break;
     627             :                             }
     628             :                         }
     629             : 
     630           0 :                         if (i >= nCounts)
     631             :                         {
     632           0 :                             Color  aBlack (0, 0, 0);
     633           0 :                             XHatch aHatch (aBlack, (XHatchStyle) pStyle->GetValue (), pDistance->GetValue (),
     634           0 :                                            pAngle->GetValue () * 10);
     635             : 
     636           0 :                             pHatchList->Insert (new XHatchEntry (aHatch, pName->GetValue ()));
     637           0 :                             pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE);
     638           0 :                             pAttr->Put (XFillHatchItem (pName->GetValue (), aHatch), XATTR_FILLHATCH);
     639             :                         }
     640             : 
     641           0 :                         rBindings.Invalidate (SID_ATTR_FILL_HATCH);
     642           0 :                         rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     643             :                     }
     644             : #ifndef DISABLE_SCRIPTING
     645           0 :                     else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE);
     646             : #endif
     647           0 :                     break;
     648             :                 }
     649             : #ifndef DISABLE_SCRIPTING
     650           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     651             : #endif
     652           0 :             break;
     653             : 
     654             :         case SID_SELECTGRADIENT :
     655           0 :             if (pArgs)
     656           0 :                 if (pArgs->Count () == 1)
     657             :                 {
     658           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     659             : 
     660           0 :                     XGradientListRef pGradientList = GetDoc()->GetGradientList ();
     661           0 :                     long           nCounts        = pGradientList->Count ();
     662             : 
     663           0 :                     for (long i = 0;
     664             :                               i < nCounts;
     665             :                               i ++)
     666             :                     {
     667           0 :                         XGradientEntry *pEntry = pGradientList->GetGradient (i);
     668             : 
     669           0 :                         if (pEntry->GetName () == pName->GetValue ())
     670             :                         {
     671           0 :                             pAttr->ClearItem (XATTR_FILLGRADIENT);
     672           0 :                             pAttr->ClearItem (XATTR_FILLSTYLE);
     673           0 :                             pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE);
     674           0 :                             pAttr->Put (XFillGradientItem (pName->GetValue (), pEntry->GetGradient ()), XATTR_FILLGRADIENT);
     675             : 
     676           0 :                             rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
     677           0 :                             rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     678           0 :                             break;
     679             :                         }
     680             :                     }
     681             : 
     682           0 :                     break;
     683             :                 }
     684             : #ifndef DISABLE_SCRIPTING
     685           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     686             : #endif
     687           0 :             break;
     688             : 
     689             :         case SID_SELECTHATCH :
     690           0 :             if (pArgs)
     691           0 :                 if (pArgs->Count () == 1)
     692             :                 {
     693           0 :                     SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, sal_False);
     694             : 
     695           0 :                     XHatchListRef pHatchList = GetDoc()->GetHatchList ();
     696           0 :                     long       nCounts     = pHatchList->Count ();
     697             : 
     698           0 :                     for (long i = 0;
     699             :                               i < nCounts;
     700             :                               i ++)
     701             :                     {
     702           0 :                         XHatchEntry *pEntry = pHatchList->GetHatch (i);
     703             : 
     704           0 :                         if (pEntry->GetName () == pName->GetValue ())
     705             :                         {
     706           0 :                             pAttr->ClearItem (XATTR_FILLHATCH);
     707           0 :                             pAttr->ClearItem (XATTR_FILLSTYLE);
     708           0 :                             pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE);
     709           0 :                             pAttr->Put (XFillHatchItem (pName->GetValue (), pEntry->GetHatch ()), XATTR_FILLHATCH);
     710             : 
     711           0 :                             rBindings.Invalidate (SID_ATTR_FILL_HATCH);
     712           0 :                             rBindings.Invalidate (SID_ATTR_FILL_STYLE);
     713           0 :                             break;
     714             :                         }
     715             :                     }
     716             : 
     717           0 :                     break;
     718             :                 }
     719             : #ifndef DISABLE_SCRIPTING
     720           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     721             : #endif
     722           0 :             break;
     723             : 
     724             :         case SID_UNSELECT :
     725           0 :             mpDrawView->UnmarkAll ();
     726           0 :             break;
     727             : 
     728             :         case SID_GETRED :
     729           0 :             if (pArgs)
     730           0 :                 if (pArgs->Count () == 1)
     731             :                 {
     732           0 :                     break;
     733             :                 }
     734             : #ifndef DISABLE_SCRIPTING
     735           0 :             StarBASIC::FatalError (SbERR_WRONG_ARGS);
     736             : #endif
     737           0 :             break;
     738             : 
     739             : /*        case SID_SETFONTFAMILYNAME :
     740             :         case SID_SETFONTSTYLENAME :
     741             :         case SID_SETFONTFAMILY :
     742             :         case SID_SETFONTPITCH :
     743             :         case SID_SETFONTCHARSET :
     744             :         case SID_SETFONTPOSTURE :
     745             :         case SID_SETFONTWEIGHT :
     746             :         case SID_SETFONTUNDERLINE :
     747             :         case SID_SETFONTCROSSEDOUT :
     748             :         case SID_SETFONTSHADOWED :
     749             :         case SID_SETFONTCONTOUR :
     750             :         case SID_SETFONTCOLOR :
     751             :         case SID_SETFONTLANGUAGE :
     752             :         case SID_SETFONTWORDLINE :
     753             :         case SID_SETFONTCASEMAP :
     754             :         case SID_SETFONTESCAPE :
     755             :         case SID_SETFONTKERNING :
     756             :             break;*/
     757             : 
     758             :         default :
     759             :             ;
     760             :     }
     761             : 
     762           0 :     mpDrawView->SetAttributes (*(const SfxItemSet *) pAttr);
     763           0 :     rReq.Ignore ();
     764           0 :     delete pAttr;
     765             : }
     766             : 
     767             : /*************************************************************************
     768             : |*
     769             : |* Makros fuer die Attributeinstellungen bearbeiten
     770             : |*
     771             : \************************************************************************/
     772             : 
     773           0 : void DrawViewShell::AttrState (SfxItemSet& rSet)
     774             : {
     775           0 :     SfxWhichIter     aIter (rSet);
     776           0 :     sal_uInt16           nWhich = aIter.FirstWhich ();
     777           0 :     SfxItemSet aAttr( GetDoc()->GetPool() );
     778           0 :     mpDrawView->GetAttributes( aAttr );
     779             : 
     780           0 :     while (nWhich)
     781             :     {
     782           0 :         switch (nWhich)
     783             :         {
     784             :             case SID_GETFILLSTYLE :
     785             :             {
     786           0 :                 const XFillStyleItem &rFillStyleItem = (const XFillStyleItem &) aAttr.Get (XATTR_FILLSTYLE);
     787             : 
     788           0 :                 rSet.Put (SfxUInt32Item (nWhich, (long) rFillStyleItem.GetValue ()));
     789           0 :                 break;
     790             :             }
     791             : 
     792             :             case SID_GETLINESTYLE :
     793             :             {
     794           0 :                 const XLineStyleItem &rLineStyleItem = (const XLineStyleItem &) aAttr.Get (XATTR_LINESTYLE);
     795             : 
     796           0 :                 rSet.Put (SfxUInt32Item (nWhich, (long) rLineStyleItem.GetValue ()));
     797           0 :                 break;
     798             :             }
     799             : 
     800             :             case SID_GETLINEWIDTH :
     801             :             {
     802           0 :                 const XLineWidthItem &rLineWidthItem = (const XLineWidthItem &) aAttr.Get (XATTR_LINEWIDTH);
     803             : 
     804           0 :                 rSet.Put (SfxUInt32Item (nWhich, (long) rLineWidthItem.GetValue ()));
     805           0 :                 break;
     806             :             }
     807             : 
     808             :             case SID_GETGREEN :
     809             :             case SID_GETRED :
     810             :             case SID_GETBLUE :
     811             :             {
     812           0 :                 const SfxUInt32Item &rWhatKind = (const SfxUInt32Item &) rSet.Get (ID_VAL_WHATKIND);
     813           0 :                 Color               aColor;
     814             : 
     815           0 :                 switch (rWhatKind.GetValue ())
     816             :                 {
     817             :                     case 1 :
     818             :                     {
     819           0 :                         const XLineColorItem &rLineColorItem = (const XLineColorItem &) aAttr.Get (XATTR_LINECOLOR);
     820             : 
     821           0 :                         aColor = rLineColorItem.GetColorValue ();
     822           0 :                         break;
     823             :                     }
     824             : 
     825             :                     case 2 :
     826             :                     {
     827           0 :                         const XFillColorItem &rFillColorItem = (const XFillColorItem &) aAttr.Get (XATTR_FILLCOLOR);
     828             : 
     829           0 :                         aColor = rFillColorItem.GetColorValue ();
     830           0 :                         break;
     831             :                     }
     832             : 
     833             :                     case 3 :
     834             :                     case 4 :
     835             :                     {
     836           0 :                         const XFillGradientItem &rFillGradientItem = (const XFillGradientItem &) aAttr.Get (XATTR_FILLGRADIENT);
     837           0 :                         const XGradient         &rGradient         = rFillGradientItem.GetGradientValue ();
     838             : 
     839           0 :                         aColor = (rWhatKind.GetValue () == 3)
     840             :                                     ? rGradient.GetStartColor ()
     841           0 :                                     : rGradient.GetEndColor ();
     842           0 :                         break;
     843             :                     }
     844             : 
     845             :                     case 5:
     846             :                     {
     847           0 :                         const XFillHatchItem &rFillHatchItem = (const XFillHatchItem &) aAttr.Get (XATTR_FILLHATCH);
     848           0 :                         const XHatch         &rHatch         = rFillHatchItem.GetHatchValue ();
     849             : 
     850           0 :                         aColor = rHatch.GetColor ();
     851           0 :                         break;
     852             :                     }
     853             : 
     854             :                     default :
     855             :                         ;
     856             :                 }
     857             : 
     858             :                 rSet.Put (SfxUInt32Item (nWhich, (long) ((nWhich == SID_GETRED)
     859           0 :                                                              ? aColor.GetRed ()
     860             :                                                              : (nWhich == SID_GETGREEN)
     861           0 :                                                                    ? aColor.GetGreen ()
     862           0 :                                                                    : aColor.GetBlue ())));
     863             :                 break;
     864             :             }
     865             : 
     866             :             default :
     867             :                 ;
     868             :         }
     869             : 
     870           0 :         nWhich = aIter.NextWhich ();
     871           0 :     }
     872           0 : }
     873             : 
     874             : } // end of namespace sd
     875             : 
     876             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10