starmath/source/utility.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_starmath.hxx"
  30
  31
  32 #include <sfx2/app.hxx>
  33 #include <vcl/virdev.hxx>
  34 #include <tools/string.hxx>
  35 #include <tools/tenccvt.hxx>
  36 #include <osl/thread.h>
  37
  38 #include <tools/stream.hxx>
  39
  40 #include "starmath.hrc"
  41
  42 #include "utility.hxx"
  43 #include "dialog.hxx"
  44 #include "view.hxx"
  45 #include "smdll.hxx"
  46
  47
  48 // return pointer to active SmViewShell, if this is not possible
  49 // return 0 instead.
  50 //!! Since this method is based on the current focus it is somewhat
  51 //!! unreliable and may return unexpected 0 pointers!
  52 SmViewShell * SmGetActiveView()
  53 {
  54     SfxViewShell *pView = SfxViewShell::Current();
  55     return PTR_CAST(SmViewShell, pView);
  56 }
  57
  58
  59 ////////////////////////////////////////////////////////////
  60
  61
  62 /**************************************************************************/
  63
  64 SmPickList::SmPickList(USHORT nInitSize, USHORT nMaxSize) :
  65     SfxPtrArr((BYTE) nInitSize, 1)
  66 {
  67     nSize = nMaxSize;
  68 }
  69
  70
  71 SmPickList::~SmPickList()
  72 {
  73     Clear();
  74 }
  75
  76
  77 SmPickList& SmPickList::operator=(const SmPickList& rList)
  78 {
  79     USHORT  nPos;
  80
  81     Clear();
  82     nSize = rList.nSize;
  83     for (nPos = 0; nPos < rList.Count(); nPos++)
  84         InsertPtr(nPos, CreateItem(rList.Get(nPos)));
  85
  86     return *this;
  87 }
  88
  89
  90 void SmPickList::Insert(const void *pItem)
  91 {
  92     Remove(pItem);
  93     InsertPtr(0, CreateItem(pItem));
  94
  95     if (Count() > nSize)
  96     {
  97         DestroyItem(GetPtr(nSize));
  98         RemovePtr(nSize, 1);
  99     }
 100 }
 101
 102
 103 void SmPickList::Update(const void *pItem, const void *pNewItem)
 104 {
 105     USHORT  nPos;
 106
 107     for (nPos = 0; nPos < Count(); nPos++)
 108         if (CompareItem(GetPtr(nPos), pItem))
 109         {
 110             DestroyItem(GetPtr(nPos));
 111             GetPtr(nPos) = CreateItem(pNewItem);
 112             break;
 113         }
 114 }
 115
 116 void SmPickList::Remove(const void *pItem)
 117 {
 118     USHORT  nPos;
 119
 120     for (nPos = 0; nPos < Count(); nPos++)
 121         if (CompareItem(GetPtr(nPos), pItem))
 122         {
 123             DestroyItem(GetPtr(nPos));
 124             RemovePtr(nPos, 1);
 125             break;
 126         }
 127 }
 128
 129 void SmPickList::Clear()
 130 {
 131     USHORT  nPos;
 132
 133     for (nPos = 0; nPos < Count(); nPos++)
 134         DestroyItem(GetPtr(nPos));
 135
 136     RemovePtr(0, Count());
 137 }
 138
 139
 140 /**************************************************************************/
 141 /**************************************************************************/
 142
 143 void * SmFontPickList::CreateItem(const String& /*rString*/)
 144 {
 145     return new Font();
 146 }
 147
 148 void * SmFontPickList::CreateItem(const void *pItem)
 149 {
 150     return new Font(*((Font *) pItem));
 151 }
 152
 153 void SmFontPickList::DestroyItem(void *pItem)
 154 {
 155     delete (Font *)pItem;
 156 }
 157
 158 BOOL SmFontPickList::CompareItem(const void *pFirstItem, const void *pSecondItem) const
 159 {
 160     Font    *pFirstFont, *pSecondFont;
 161
 162     pFirstFont  = (Font *)pFirstItem;
 163     pSecondFont = (Font *)pSecondItem;
 164
 165     if (pFirstFont->GetName() == pSecondFont->GetName())
 166         if ((pFirstFont->GetFamily()  == pSecondFont->GetFamily())  &&
 167             (pFirstFont->GetCharSet() == pSecondFont->GetCharSet()) &&
 168             (pFirstFont->GetWeight()  == pSecondFont->GetWeight())  &&
 169             (pFirstFont->GetItalic()  == pSecondFont->GetItalic()))
 170             return (TRUE);
 171
 172     return FALSE;
 173 }
 174
 175 String SmFontPickList::GetStringItem(void *pItem)
 176 {
 177     Font   *pFont;
 178     String  aString;
 179     const sal_Char *pDelim = ", ";
 180
 181     pFont = (Font *)pItem;
 182
 183     aString = pFont->GetName();
 184
 185     if (IsItalic( *pFont ))
 186     {
 187         aString.AppendAscii( pDelim );
 188         aString += String(SmResId(RID_FONTITALIC));
 189     }
 190     if (IsBold( *pFont ))    // bold?
 191     {
 192         aString.AppendAscii( pDelim );
 193         aString += String(SmResId(RID_FONTBOLD));
 194     }
 195
 196     return (aString);
 197 }
 198
 199 void SmFontPickList::Insert(const Font &rFont)
 200 {
 201     SmPickList::Insert((void *)&rFont);
 202 }
 203
 204 void SmFontPickList::Update(const Font &rFont, const Font &rNewFont)
 205 {
 206     SmPickList::Update((void *)&rFont, (void *)&rNewFont);
 207 }
 208
 209 void SmFontPickList::Remove(const Font &rFont)
 210 {
 211     SmPickList::Remove((void *)&rFont);
 212 }
 213
 214
 215 void SmFontPickList::ReadFrom(const SmFontDialog& rDialog)
 216 {
 217     Insert(rDialog.GetFont());
 218 }
 219
 220 void SmFontPickList::WriteTo(SmFontDialog& rDialog) const
 221 {
 222     rDialog.SetFont(Get());
 223 }
 224
 225
 226 /**************************************************************************/
 227
 228
 229 /**************************************************************************/
 230
 231 IMPL_LINK( SmFontPickListBox, SelectHdl, ListBox *, /*pListBox*/ )
 232 {
 233     USHORT  nPos;
 234     String  aString;
 235
 236     nPos = GetSelectEntryPos();
 237
 238     if (nPos != 0)
 239     {
 240         SmFontPickList::Insert(Get(nPos));
 241         aString = GetEntry(nPos);
 242         RemoveEntry(nPos);
 243         InsertEntry(aString, 0);
 244     }
 245
 246     SelectEntryPos(0);
 247
 248     return 0;
 249 }
 250
 251
 252 SmFontPickListBox::SmFontPickListBox(Window* pParent, const ResId& rResId, USHORT nMax) :
 253     SmFontPickList(nMax, nMax),
 254     ListBox(pParent, rResId)
 255 {
 256     SetSelectHdl(LINK(this, SmFontPickListBox, SelectHdl));
 257 }
 258
 259
 260 SmFontPickListBox& SmFontPickListBox::operator=(const SmFontPickList& rList)
 261 {
 262     USHORT nPos;
 263
 264     *(SmFontPickList *)this = rList;
 265
 266     for (nPos = 0; nPos < Count(); nPos++)
 267         InsertEntry(GetStringItem(GetPtr(nPos)), nPos);
 268
 269     if (Count() > 0)
 270         SelectEntry(GetStringItem(GetPtr(0)));
 271
 272     return *this;
 273 }
 274
 275 void SmFontPickListBox::Insert(const Font &rFont)
 276 {
 277     SmFontPickList::Insert(rFont);
 278
 279     RemoveEntry(GetStringItem(GetPtr(0)));
 280     InsertEntry(GetStringItem(GetPtr(0)), 0);
 281     SelectEntry(GetStringItem(GetPtr(0)));
 282
 283     while (GetEntryCount() > nSize)
 284         RemoveEntry(GetEntryCount() - 1);
 285
 286     return;
 287 }
 288
 289
 290 void SmFontPickListBox::Update(const Font &rFont, const Font &rNewFont)
 291 {
 292     SmFontPickList::Update(rFont, rNewFont);
 293
 294     // ********************** hier fehlt noch was
 295
 296     return;
 297 }
 298
 299
 300 void SmFontPickListBox::Remove(const Font &rFont)
 301 {
 302     SmFontPickList::Remove(rFont);
 303
 304     // ********************** hier fehlt noch was
 305
 306     return;
 307 }
 308
 309 ////////////////////////////////////////
 310
 311 BOOL IsItalic( const Font &rFont )
 312 {
 313     FontItalic eItalic = rFont.GetItalic();
 314     // the code below leaves only _NONE and _DONTKNOW as not italic
 315     return eItalic == ITALIC_OBLIQUE  ||  eItalic == ITALIC_NORMAL;
 316 }
 317
 318
 319 BOOL IsBold( const Font &rFont )
 320 {
 321     FontWeight eWeight = rFont.GetWeight();
 322     return eWeight != WEIGHT_DONTKNOW && eWeight > WEIGHT_NORMAL;
 323 }
 324
 325
 326 void SmFace::Impl_Init()
 327 {
 328     SetSize( GetSize() );
 329     SetTransparent( TRUE );
 330     SetAlign( ALIGN_BASELINE );
 331     SetColor( COL_AUTO );
 332 }
 333
 334 void SmFace::SetSize(const Size& rSize)
 335 {
 336     Size  aSize (rSize);
 337
 338     // check the requested size against minimum value
 339     static int __READONLY_DATA  nMinVal = SmPtsTo100th_mm(2);
 340
 341     if (aSize.Height() < nMinVal)
 342         aSize.Height() = nMinVal;
 343
 344     //! we don't force a maximum value here because this may prevent eg the
 345     //! parentheses in "left ( ... right )" from matching up with large
 346     //! bodies (eg stack{...} with many entries).
 347     //! Of course this is holds only if characters are used and not polygons.
 348
 349     Font::SetSize(aSize);
 350 }
 351
 352
 353 long SmFace::GetBorderWidth() const
 354 {
 355     if (nBorderWidth < 0)
 356         return GetDefaultBorderWidth();
 357     else
 358         return nBorderWidth;
 359 }
 360
 361 SmFace & SmFace::operator = (const SmFace &rFace)
 362 {
 363     Font::operator = (rFace);
 364     nBorderWidth = -1;
 365     return *this;
 366 }
 367
 368
 369 SmFace & operator *= (SmFace &rFace, const Fraction &rFrac)
 370     // scales the width and height of 'rFace' by 'rFrac' and returns a
 371     // reference to 'rFace'.
 372     // It's main use is to make scaling fonts look easier.
 373 {   const Size &rFaceSize = rFace.GetSize();
 374
 375     rFace.SetSize(Size(Fraction(rFaceSize.Width())  *= rFrac,
 376                        Fraction(rFaceSize.Height()) *= rFrac));
 377     return rFace;
 378 }
 379
 380
 381