starmath/source/utility.cxx

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