include/vcl/field.hxx

   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 #ifndef INCLUDED_VCL_FIELD_HXX
  21 #define INCLUDED_VCL_FIELD_HXX
  22
  23 #include <memory>
  24 #include <vcl/dllapi.h>
  25 #include <tools/link.hxx>
  26 #include <tools/date.hxx>
  27 #include <tools/time.hxx>
  28 #include <vcl/spinfld.hxx>
  29 #include <vcl/combobox.hxx>
  30 #include <tools/fldunit.hxx>
  31
  32 namespace com { namespace sun { namespace star { namespace lang { struct Locale; } } } }
  33
  34 class CalendarWrapper;
  35 class LocaleDataWrapper;
  36 class LanguageTag;
  37
  38
  39 class VCL_DLLPUBLIC FormatterBase
  40 {
  41 private:
  42     VclPtr<Edit>            mpField;
  43     std::unique_ptr<LocaleDataWrapper>
  44                             mpLocaleDataWrapper;
  45     bool                    mbReformat;
  46     bool                    mbStrictFormat;
  47     bool                    mbEmptyFieldValue;
  48     bool                    mbEmptyFieldValueEnabled;
  49
  50 protected:
  51     SAL_DLLPRIVATE void     ImplSetText( const OUString& rText, Selection const * pNewSel = nullptr );
  52     SAL_DLLPRIVATE bool     ImplGetEmptyFieldValue() const  { return mbEmptyFieldValue; }
  53
  54     void                    SetEmptyFieldValueData( bool bValue ) { mbEmptyFieldValue = bValue; }
  55
  56     SAL_DLLPRIVATE LocaleDataWrapper& ImplGetLocaleDataWrapper() const;
  57
  58     Edit*                   GetField() const            { return mpField; }
  59     void                    ClearField() { mpField.clear(); }
  60
  61 public:
  62     explicit                FormatterBase(Edit* pField);
  63     virtual                 ~FormatterBase();
  64
  65     const LocaleDataWrapper& GetLocaleDataWrapper() const;
  66
  67     bool                    MustBeReformatted() const   { return mbReformat; }
  68     void                    MarkToBeReformatted( bool b ) { mbReformat = b; }
  69
  70     void                    SetStrictFormat( bool bStrict );
  71     bool                    IsStrictFormat() const { return mbStrictFormat; }
  72
  73     virtual void            Reformat();
  74     virtual void            ReformatAll();
  75
  76     const css::lang::Locale& GetLocale() const;
  77     const LanguageTag&      GetLanguageTag() const;
  78
  79     void                    SetEmptyFieldValue();
  80     bool                    IsEmptyFieldValue() const;
  81
  82     void                    EnableEmptyFieldValue( bool bEnable )   { mbEmptyFieldValueEnabled = bEnable; }
  83     bool                    IsEmptyFieldValueEnabled() const        { return mbEmptyFieldValueEnabled; }
  84 };
  85
  86 #define PATTERN_FORMAT_EMPTYLITERALS    (sal_uInt16(0x0001))
  87
  88 class VCL_DLLPUBLIC PatternFormatter : public FormatterBase
  89 {
  90 private:
  91     OString                m_aEditMask;
  92     OUString               maLiteralMask;
  93     bool                   mbSameMask;
  94     bool                   mbInPattKeyInput;
  95
  96 protected:
  97                             PatternFormatter(Edit* pEdit);
  98
  99     SAL_DLLPRIVATE void ImplSetMask(const OString& rEditMask,
 100         const OUString& rLiteralMask);
 101     SAL_DLLPRIVATE bool     ImplIsSameMask() const { return mbSameMask; }
 102     SAL_DLLPRIVATE bool&    ImplGetInPattKeyInput() { return mbInPattKeyInput; }
 103
 104 public:
 105     virtual                 ~PatternFormatter() override;
 106
 107     virtual void            Reformat() override;
 108
 109     void SetMask(const OString& rEditMask, const OUString& rLiteralMask );
 110     const OString& GetEditMask() const { return m_aEditMask; }
 111     const OUString&        GetLiteralMask() const  { return maLiteralMask; }
 112
 113     void                    SetString( const OUString& rStr );
 114     OUString                GetString() const;
 115 };
 116
 117
 118 class VCL_DLLPUBLIC NumericFormatter : public FormatterBase
 119 {
 120 public:
 121     virtual                 ~NumericFormatter() override;
 122
 123     virtual void            Reformat() override;
 124
 125     void                    SetMin( sal_Int64 nNewMin );
 126     sal_Int64               GetMin() const { return mnMin; }
 127     void                    SetMax( sal_Int64 nNewMax );
 128     sal_Int64               GetMax() const { return mnMax; }
 129
 130     sal_Int64               ClipAgainstMinMax(sal_Int64 nValue) const;
 131
 132     void                    SetFirst( sal_Int64 nNewFirst )   { mnFirst = nNewFirst; }
 133     sal_Int64               GetFirst() const                  { return mnFirst; }
 134     void                    SetLast( sal_Int64 nNewLast )     { mnLast = nNewLast; }
 135     sal_Int64               GetLast() const                   { return mnLast; }
 136     void                    SetSpinSize( sal_Int64 nNewSize ) { mnSpinSize = nNewSize; }
 137     sal_Int64               GetSpinSize() const               { return mnSpinSize; }
 138
 139     void                    SetDecimalDigits( sal_uInt16 nDigits );
 140     sal_uInt16                  GetDecimalDigits() const { return mnDecimalDigits;}
 141
 142     void                    SetUseThousandSep( bool b );
 143     bool                    IsUseThousandSep() const { return mbThousandSep; }
 144
 145     void                    SetShowTrailingZeros( bool bShowTrailingZeros );
 146     bool                    IsShowTrailingZeros() const { return mbShowTrailingZeros; }
 147
 148     void                    SetUserValue( sal_Int64 nNewValue );
 149     virtual void            SetValue( sal_Int64 nNewValue );
 150     sal_Int64               GetValue() const;
 151     virtual OUString        CreateFieldText( sal_Int64 nValue ) const;
 152     bool                    IsValueModified() const;
 153
 154     sal_Int64               Normalize( sal_Int64 nValue ) const;
 155     sal_Int64               Denormalize( sal_Int64 nValue ) const;
 156
 157 protected:
 158     sal_Int64               mnFieldValue;
 159     sal_Int64               mnLastValue;
 160     sal_Int64               mnMin;
 161     sal_Int64               mnMax;
 162     bool                    mbWrapOnLimits;
 163     bool                    mbFormatting;
 164
 165     // the members below are used in all derivatives of NumericFormatter
 166     // not in NumericFormatter itself.
 167     sal_Int64               mnSpinSize;
 168     sal_Int64               mnFirst;
 169     sal_Int64               mnLast;
 170
 171                             NumericFormatter(Edit* pEdit);
 172
 173     void                    FieldUp();
 174     void                    FieldDown();
 175     void                    FieldFirst();
 176     void                    FieldLast();
 177     void                    FormatValue(Selection const * pNewSelection = nullptr);
 178
 179     SAL_DLLPRIVATE void     ImplNumericReformat();
 180     SAL_DLLPRIVATE void     ImplNewFieldValue( sal_Int64 nNewValue );
 181     SAL_DLLPRIVATE void     ImplSetUserValue( sal_Int64 nNewValue, Selection const * pNewSelection = nullptr );
 182
 183     virtual sal_Int64       GetValueFromString(const OUString& rStr) const;
 184
 185 private:
 186     sal_uInt16              mnDecimalDigits;
 187     bool                    mbThousandSep;
 188     bool                    mbShowTrailingZeros;
 189
 190 };
 191
 192
 193 class VCL_DLLPUBLIC MetricFormatter : public NumericFormatter
 194 {
 195 public:
 196     virtual                 ~MetricFormatter() override;
 197
 198     virtual void            CustomConvert() = 0;
 199     virtual void            Reformat() override;
 200
 201     virtual void            SetUnit( FieldUnit meUnit );
 202     FieldUnit               GetUnit() const { return meUnit; }
 203     void                    SetCustomUnitText( const OUString& rStr );
 204     const OUString&         GetCustomUnitText() const { return maCustomUnitText; }
 205
 206     using NumericFormatter::SetMax;
 207     void                    SetMax( sal_Int64 nNewMax, FieldUnit eInUnit );
 208     using NumericFormatter::GetMax;
 209     sal_Int64               GetMax( FieldUnit eOutUnit ) const;
 210     using NumericFormatter::SetMin;
 211     void                    SetMin( sal_Int64 nNewMin, FieldUnit eInUnit );
 212     using NumericFormatter::GetMin;
 213     sal_Int64               GetMin( FieldUnit eOutUnit ) const;
 214     sal_Int64               GetBaseValue() const;
 215
 216     virtual void            SetValue( sal_Int64 nNewValue, FieldUnit eInUnit );
 217     virtual void            SetValue( sal_Int64 nValue ) override;
 218     using NumericFormatter::SetUserValue;
 219     void                    SetUserValue( sal_Int64 nNewValue, FieldUnit eInUnit );
 220     using NumericFormatter::GetValue;
 221     sal_Int64               GetValue( FieldUnit eOutUnit ) const;
 222     virtual OUString        CreateFieldText( sal_Int64 nValue ) const override;
 223     sal_Int64               GetCorrectedValue( FieldUnit eOutUnit ) const;
 224
 225     static FieldUnit        StringToMetric(const OUString &rMetricString);
 226     static bool             TextToValue(const OUString& rStr, double& rValue, sal_Int64 nBaseValue, sal_uInt16 nDecDigits, const LocaleDataWrapper& rLocaleDataWrapper, FieldUnit eUnit);
 227
 228 protected:
 229     sal_Int64               mnBaseValue;
 230     FieldUnit               meUnit;
 231     Link<MetricFormatter&,void> maCustomConvertLink;
 232
 233                             MetricFormatter(Edit* pEdit);
 234
 235     SAL_DLLPRIVATE void     ImplMetricReformat( const OUString& rStr, double& rValue, OUString& rOutStr );
 236
 237     virtual sal_Int64       GetValueFromString(const OUString& rStr) const override;
 238     virtual sal_Int64       GetValueFromStringUnit(const OUString& rStr, FieldUnit eOutUnit) const;
 239
 240 private:
 241     OUString                maCustomUnitText;
 242     OUString                maCurUnitText;
 243 };
 244
 245
 246 class VCL_DLLPUBLIC CurrencyFormatter : public NumericFormatter
 247 {
 248 protected:
 249                             CurrencyFormatter(Edit* pEdit);
 250     SAL_DLLPRIVATE void     ImplCurrencyReformat( const OUString& rStr, OUString& rOutStr );
 251     virtual sal_Int64       GetValueFromString(const OUString& rStr) const override;
 252
 253 public:
 254     virtual                 ~CurrencyFormatter() override;
 255
 256     virtual void            Reformat() override;
 257
 258     virtual void            SetValue( sal_Int64 nNewValue ) override;
 259     virtual OUString        CreateFieldText( sal_Int64 nValue ) const override;
 260 };
 261
 262
 263 class VCL_DLLPUBLIC DateFormatter : public FormatterBase
 264 {
 265 private:
 266     std::unique_ptr<CalendarWrapper> mxCalendarWrapper;
 267     Date                    maFieldDate;
 268     Date                    maLastDate;
 269     Date                    maMin;
 270     Date                    maMax;
 271     bool                    mbLongFormat;
 272     bool                    mbShowDateCentury;
 273     ExtDateFieldFormat      mnExtDateFormat;
 274     bool                    mbEnforceValidValue;
 275
 276 protected:
 277                             DateFormatter(Edit* pEdit);
 278
 279     SAL_DLLPRIVATE const Date& ImplGetFieldDate() const    { return maFieldDate; }
 280     SAL_DLLPRIVATE void     ImplDateReformat( const OUString& rStr, OUString& rOutStr );
 281     SAL_DLLPRIVATE void     ImplSetUserDate( const Date& rNewDate,
 282                                              Selection const * pNewSelection = nullptr );
 283     SAL_DLLPRIVATE OUString ImplGetDateAsText( const Date& rDate ) const;
 284     SAL_DLLPRIVATE void     ImplNewFieldValue( const Date& rDate );
 285     CalendarWrapper&        GetCalendarWrapper() const;
 286
 287     SAL_DLLPRIVATE bool     ImplAllowMalformedInput() const;
 288
 289 public:
 290     virtual                 ~DateFormatter() override;
 291
 292     virtual void            Reformat() override;
 293     virtual void            ReformatAll() override;
 294
 295     void                    SetExtDateFormat( ExtDateFieldFormat eFormat );
 296     ExtDateFieldFormat      GetExtDateFormat( bool bResolveSystemFormat = false ) const;
 297
 298     void                    SetMin( const Date& rNewMin );
 299     const Date&             GetMin() const { return maMin; }
 300
 301     void                    SetMax( const Date& rNewMax );
 302     const Date&             GetMax() const { return maMax; }
 303
 304
 305     // MT: Remove these methods too, ExtDateFormat should be enough!
 306     //     What should happen if using DDMMYYYY, but ShowCentury=false?
 307
 308     void                    SetLongFormat( bool bLong );
 309     bool                    IsLongFormat() const { return mbLongFormat; }
 310     void                    SetShowDateCentury( bool bShowCentury );
 311     bool                    IsShowDateCentury() const { return mbShowDateCentury; }
 312
 313
 314     void                    SetDate( const Date& rNewDate );
 315     Date                    GetDate() const;
 316     void                    SetEmptyDate();
 317     bool                    IsEmptyDate() const;
 318
 319     void                    ResetLastDate() { maLastDate = Date( Date::EMPTY ); }
 320
 321     static void             ExpandCentury( Date& rDate );
 322     static void             ExpandCentury( Date& rDate, sal_uInt16 nTwoDigitYearStart );
 323
 324     /** enables or disables the enforcement of valid values
 325
 326         If this is set to true (which is the default), then GetDate will always return a valid
 327         date, no matter whether the current text can really be interpreted as date. (Note: this
 328         is the compatible behavior).
 329
 330         If this is set to false, the GetDate will return GetInvalidDate, in case the current text
 331         cannot be interpreted as date.
 332
 333         In addition, if this is set to false, the text in the field will \em not be corrected
 334         when the control loses the focus - instead, the invalid input will be preserved.
 335     */
 336     void                    EnforceValidValue( bool _bEnforce ) { mbEnforceValidValue = _bEnforce; }
 337     bool             IsEnforceValidValue( ) const { return mbEnforceValidValue; }
 338 };
 339
 340
 341 class VCL_DLLPUBLIC TimeFormatter : public FormatterBase
 342 {
 343 private:
 344     tools::Time             maLastTime;
 345     tools::Time             maMin;
 346     tools::Time             maMax;
 347     TimeFieldFormat         meFormat;
 348     TimeFormat              mnTimeFormat;
 349     bool                    mbDuration;
 350     bool                    mbEnforceValidValue;
 351
 352 protected:
 353     tools::Time             maFieldTime;
 354
 355                             TimeFormatter(Edit* pEdit);
 356
 357     SAL_DLLPRIVATE void     ImplTimeReformat( const OUString& rStr, OUString& rOutStr );
 358     SAL_DLLPRIVATE void     ImplNewFieldValue( const tools::Time& rTime );
 359     SAL_DLLPRIVATE void     ImplSetUserTime( const tools::Time& rNewTime, Selection const * pNewSelection = nullptr );
 360     SAL_DLLPRIVATE bool     ImplAllowMalformedInput() const;
 361
 362 public:
 363     static OUString         FormatTime(const tools::Time& rNewTime, TimeFieldFormat eFormat, TimeFormat eHourFormat, bool bDuration, const LocaleDataWrapper& rLocaleData);
 364     static bool             TextToTime(const OUString& rStr, tools::Time& rTime, TimeFieldFormat eFormat, bool bDuration, const LocaleDataWrapper& rLocaleDataWrapper, bool _bSkipInvalidCharacters = true);
 365     static int              GetTimeArea(TimeFieldFormat eFormat, const OUString& rText, int nCursor,
 366                                         const LocaleDataWrapper& rLocaleDataWrapper);
 367     static tools::Time      SpinTime(bool bUp, const tools::Time& rTime, TimeFieldFormat eFormat,
 368                                      bool bDuration, const OUString& rText, int nCursor,
 369                                      const LocaleDataWrapper& rLocaleDataWrapper);
 370
 371     virtual                 ~TimeFormatter() override;
 372
 373     virtual void            Reformat() override;
 374     virtual void            ReformatAll() override;
 375
 376     void                    SetMin( const tools::Time& rNewMin );
 377     const tools::Time&             GetMin() const { return maMin; }
 378     void                    SetMax( const tools::Time& rNewMax );
 379     const tools::Time&             GetMax() const { return maMax; }
 380
 381     void                    SetTimeFormat( TimeFormat eNewFormat );
 382     TimeFormat              GetTimeFormat() const { return mnTimeFormat;}
 383
 384     void                    SetFormat( TimeFieldFormat eNewFormat );
 385     TimeFieldFormat         GetFormat() const { return meFormat; }
 386
 387     void                    SetDuration( bool mbDuration );
 388     bool                    IsDuration() const { return mbDuration; }
 389
 390     void                    SetTime( const tools::Time& rNewTime );
 391     void                    SetUserTime( const tools::Time& rNewTime );
 392     tools::Time             GetTime() const;
 393     void                    SetEmptyTime() { FormatterBase::SetEmptyFieldValue(); }
 394     bool                    IsEmptyTime() const { return FormatterBase::IsEmptyFieldValue(); }
 395
 396     /** enables or disables the enforcement of valid values
 397
 398         If this is set to true (which is the default), then GetTime will always return a valid
 399         time, no matter whether the current text can really be interpreted as time. (Note: this
 400         is the compatible behavior).
 401
 402         If this is set to false, the GetTime will return GetInvalidTime, in case the current text
 403         cannot be interpreted as time.
 404
 405         In addition, if this is set to false, the text in the field will <em>not</em> be corrected
 406         when the control loses the focus - instead, the invalid input will be preserved.
 407     */
 408     void                    EnforceValidValue( bool _bEnforce ) { mbEnforceValidValue = _bEnforce; }
 409     bool             IsEnforceValidValue( ) const { return mbEnforceValidValue; }
 410 };
 411
 412
 413 class VCL_DLLPUBLIC PatternField final : public SpinField, public PatternFormatter
 414 {
 415 public:
 416     explicit                PatternField( vcl::Window* pParent, WinBits nWinStyle );
 417
 418     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 419     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 420     virtual void            Modify() override;
 421     virtual void            dispose() override;
 422 };
 423
 424
 425 class VCL_DLLPUBLIC NumericField : public SpinField, public NumericFormatter
 426 {
 427 public:
 428     explicit                NumericField( vcl::Window* pParent, WinBits nWinStyle );
 429
 430     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 431     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 432     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 433
 434     virtual Size            CalcMinimumSize() const override;
 435
 436     virtual void            Modify() override;
 437
 438     virtual void            Up() override;
 439     virtual void            Down() override;
 440     virtual void            First() override;
 441     virtual void            Last() override;
 442     virtual bool            set_property(const OString &rKey, const OUString &rValue) override;
 443     virtual void            dispose() override;
 444
 445     virtual boost::property_tree::ptree DumpAsPropertyTree() override;
 446 };
 447
 448
 449 class VCL_DLLPUBLIC MetricField : public SpinField, public MetricFormatter
 450 {
 451 public:
 452     explicit                MetricField( vcl::Window* pParent, WinBits nWinStyle );
 453
 454     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 455     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 456     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 457
 458     virtual Size            CalcMinimumSize() const override;
 459
 460     virtual void            Modify() override;
 461
 462     virtual void            Up() override;
 463     virtual void            Down() override;
 464     virtual void            First() override;
 465     virtual void            Last() override;
 466     virtual void            CustomConvert() override;
 467
 468     virtual void            SetUnit( FieldUnit meUnit ) override;
 469
 470     void                    SetFirst( sal_Int64 nNewFirst, FieldUnit eInUnit );
 471     void             SetFirst(sal_Int64 first) { SetFirst(first, FieldUnit::NONE); }
 472     sal_Int64               GetFirst( FieldUnit eOutUnit ) const;
 473     void                    SetLast( sal_Int64 nNewLast, FieldUnit eInUnit );
 474     void             SetLast(sal_Int64 last) { SetLast(last, FieldUnit::NONE); }
 475     sal_Int64               GetLast( FieldUnit eOutUnit ) const;
 476
 477     static sal_Int64        ConvertValue( sal_Int64 nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits,
 478                                           FieldUnit eInUnit, FieldUnit eOutUnit );
 479     static sal_Int64        ConvertValue( sal_Int64 nValue, sal_uInt16 nDecDigits,
 480                                           MapUnit eInUnit, FieldUnit eOutUnit );
 481
 482     // for backwards compatibility
 483     // caution: conversion to double loses precision
 484     static double           ConvertDoubleValue( double nValue, sal_Int64 mnBaseValue, sal_uInt16 nDecDigits,
 485                                                 FieldUnit eInUnit, FieldUnit eOutUnit );
 486     static double           ConvertDoubleValue( double nValue, sal_uInt16 nDecDigits,
 487                                                 FieldUnit eInUnit, MapUnit eOutUnit );
 488     static double           ConvertDoubleValue( double nValue, sal_uInt16 nDecDigits,
 489                                                 MapUnit eInUnit, FieldUnit eOutUnit );
 490
 491     // for backwards compatibility
 492     // caution: conversion to double loses precision
 493     static double           ConvertDoubleValue( sal_Int64 nValue, sal_Int64 nBaseValue, sal_uInt16 nDecDigits,
 494                                                 FieldUnit eInUnit, FieldUnit eOutUnit )
 495     { return ConvertDoubleValue( static_cast<double>(nValue), nBaseValue, nDecDigits, eInUnit, eOutUnit ); }
 496     static double           ConvertDoubleValue( sal_Int64 nValue, sal_uInt16 nDecDigits,
 497                                                 FieldUnit eInUnit, MapUnit eOutUnit )
 498     { return ConvertDoubleValue( static_cast<double>(nValue), nDecDigits, eInUnit, eOutUnit ); }
 499     static double           ConvertDoubleValue( sal_Int64 nValue, sal_uInt16 nDecDigits,
 500                                                 MapUnit eInUnit, FieldUnit eOutUnit )
 501     { return ConvertDoubleValue( static_cast<double>(nValue), nDecDigits, eInUnit, eOutUnit ); }
 502
 503     virtual bool            set_property(const OString &rKey, const OUString &rValue) override;
 504     virtual void            dispose() override;
 505
 506     virtual boost::property_tree::ptree DumpAsPropertyTree() override;
 507 };
 508
 509
 510 class VCL_DLLPUBLIC CurrencyField final : public SpinField, public CurrencyFormatter
 511 {
 512 public:
 513     CurrencyField( vcl::Window* pParent, WinBits nWinStyle );
 514
 515     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 516     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 517     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 518
 519     virtual void            Modify() override;
 520
 521     virtual void            Up() override;
 522     virtual void            Down() override;
 523     virtual void            First() override;
 524     virtual void            Last() override;
 525     virtual void            dispose() override;
 526 };
 527
 528
 529 class VCL_DLLPUBLIC DateField : public SpinField, public DateFormatter
 530 {
 531 private:
 532     Date                    maFirst;
 533     Date                    maLast;
 534
 535 protected:
 536     SAL_DLLPRIVATE void     ImplDateSpinArea( bool bUp );
 537
 538 public:
 539     explicit                DateField( vcl::Window* pParent, WinBits nWinStyle );
 540
 541     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 542     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 543     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 544
 545     virtual void            Modify() override;
 546
 547     virtual void            Up() override;
 548     virtual void            Down() override;
 549     virtual void            First() override;
 550     virtual void            Last() override;
 551
 552     void                    SetFirst( const Date& rNewFirst )   { maFirst = rNewFirst; }
 553     const Date&             GetFirst() const                    { return maFirst; }
 554     void                    SetLast( const Date& rNewLast )     { maLast = rNewLast; }
 555     const Date&             GetLast() const                     { return maLast; }
 556     virtual void            dispose() override;
 557 };
 558
 559
 560 class VCL_DLLPUBLIC TimeField final : public SpinField, public TimeFormatter
 561 {
 562 private:
 563     tools::Time                    maFirst;
 564     tools::Time                    maLast;
 565
 566     SAL_DLLPRIVATE void     ImplTimeSpinArea( bool bUp );
 567
 568 public:
 569     explicit                TimeField( vcl::Window* pParent, WinBits nWinStyle );
 570
 571     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 572     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 573     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 574
 575     virtual void            Modify() override;
 576
 577     virtual void            Up() override;
 578     virtual void            Down() override;
 579     virtual void            First() override;
 580     virtual void            Last() override;
 581
 582     void                    SetFirst( const tools::Time& rNewFirst )   { maFirst = rNewFirst; }
 583     const tools::Time&      GetFirst() const                    { return maFirst; }
 584     void                    SetLast( const tools::Time& rNewLast )     { maLast = rNewLast; }
 585     const tools::Time&      GetLast() const                     { return maLast; }
 586
 587     void                    SetExtFormat( ExtTimeFieldFormat eFormat );
 588     virtual void            dispose() override;
 589 };
 590
 591
 592 class VCL_DLLPUBLIC PatternBox final : public ComboBox, public PatternFormatter
 593 {
 594 public:
 595                             PatternBox( vcl::Window* pParent, WinBits nWinStyle );
 596
 597     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 598     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 599
 600     virtual void            Modify() override;
 601
 602     virtual void            ReformatAll() override;
 603     virtual void            dispose() override;
 604 };
 605
 606
 607 class VCL_DLLPUBLIC NumericBox : public ComboBox, public NumericFormatter
 608 {
 609     SAL_DLLPRIVATE void     ImplNumericReformat( const OUString& rStr, sal_Int64& rValue, OUString& rOutStr );
 610 public:
 611     explicit                NumericBox( vcl::Window* pParent, WinBits nWinStyle );
 612
 613     virtual Size            CalcMinimumSize() const override;
 614
 615     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 616     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 617     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 618
 619     virtual void            Modify() override;
 620
 621     virtual void            ReformatAll() override;
 622
 623     void                    InsertValue( sal_Int64 nValue, sal_Int32  nPos = COMBOBOX_APPEND );
 624     virtual void            dispose() override;
 625 };
 626
 627
 628 class VCL_DLLPUBLIC MetricBox : public ComboBox, public MetricFormatter
 629 {
 630 public:
 631     explicit                MetricBox( vcl::Window* pParent, WinBits nWinStyle );
 632
 633     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 634     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 635     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 636
 637     virtual Size            CalcMinimumSize() const override;
 638
 639     virtual void            Modify() override;
 640
 641     virtual void            CustomConvert() override;
 642     virtual void            ReformatAll() override;
 643
 644     void                    InsertValue( sal_Int64 nValue, FieldUnit eInUnit = FieldUnit::NONE,
 645                                          sal_Int32  nPos = COMBOBOX_APPEND );
 646
 647     // Needed, because GetValue() with nPos hide these functions
 648     using MetricFormatter::GetValue;
 649
 650     virtual void            dispose() override;
 651 };
 652
 653
 654 class VCL_DLLPUBLIC CurrencyBox final : public ComboBox, public CurrencyFormatter
 655 {
 656 public:
 657     explicit                CurrencyBox( vcl::Window* pParent, WinBits nWinStyle );
 658
 659     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 660     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 661     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 662
 663     virtual void            Modify() override;
 664
 665     virtual void            ReformatAll() override;
 666
 667     virtual void            dispose() override;
 668 };
 669
 670
 671 class VCL_DLLPUBLIC DateBox final : public ComboBox, public DateFormatter
 672 {
 673 public:
 674     explicit                DateBox( vcl::Window* pParent, WinBits nWinStyle );
 675
 676     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 677     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 678     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 679
 680     virtual void            Modify() override;
 681
 682     virtual void            ReformatAll() override;
 683     virtual void            dispose() override;
 684 };
 685
 686
 687 class VCL_DLLPUBLIC TimeBox final : public ComboBox, public TimeFormatter
 688 {
 689 public:
 690     explicit                TimeBox( vcl::Window* pParent, WinBits nWinStyle );
 691
 692     virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
 693     virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
 694     virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
 695
 696     virtual void            Modify() override;
 697
 698     virtual void            ReformatAll() override;
 699     virtual void            dispose() override;
 700 };
 701
 702 #endif // INCLUDED_VCL_FIELD_HXX
 703
 704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */