← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to src/common/textcmn.cpp

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common/textcmn.cpp
 
1
///////////////////////////////////////////////////////////////////////////////
 
2
// Name:        common/textcmn.cpp
 
3
// Purpose:     implementation of platform-independent functions of wxTextCtrl
 
4
// Author:      Julian Smart
 
5
// Modified by:
 
6
// Created:     13.07.99
 
7
// RCS-ID:      $Id: textcmn.cpp,v 1.43 2005/07/21 16:19:40 ABX Exp $
 
8
// Copyright:   (c) wxWidgets team
 
9
// Licence:     wxWindows licence
 
10
///////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
// ============================================================================
 
13
// declarations
 
14
// ============================================================================
 
15
 
 
16
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
 
17
    #pragma implementation "textctrlbase.h"
 
18
#endif
 
19
 
 
20
// for compilers that support precompilation, includes "wx.h".
 
21
#include "wx/wxprec.h"
 
22
 
 
23
#ifdef __BORLANDC__
 
24
    #pragma hdrstop
 
25
#endif
 
26
 
 
27
#if wxUSE_TEXTCTRL
 
28
 
 
29
#ifndef WX_PRECOMP
 
30
    #include "wx/intl.h"
 
31
    #include "wx/log.h"
 
32
    #include "wx/textctrl.h"
 
33
#endif // WX_PRECOMP
 
34
 
 
35
#include "wx/ffile.h"
 
36
 
 
37
// ----------------------------------------------------------------------------
 
38
// macros
 
39
// ----------------------------------------------------------------------------
 
40
 
 
41
// we don't have any objects of type wxTextCtrlBase in the program, only
 
42
// wxTextCtrl, so this cast is safe
 
43
#define TEXTCTRL(ptr)   ((wxTextCtrl *)(ptr))
 
44
 
 
45
// ============================================================================
 
46
// implementation
 
47
// ============================================================================
 
48
 
 
49
IMPLEMENT_DYNAMIC_CLASS(wxTextUrlEvent, wxCommandEvent)
 
50
 
 
51
DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_UPDATED)
 
52
DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_ENTER)
 
53
DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_URL)
 
54
DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_MAXLEN)
 
55
 
 
56
// ----------------------------------------------------------------------------
 
57
// style functions - not implemented here
 
58
// ----------------------------------------------------------------------------
 
59
 
 
60
wxTextAttr::wxTextAttr(const wxColour& colText,
 
61
               const wxColour& colBack,
 
62
               const wxFont& font,
 
63
               wxTextAttrAlignment alignment)
 
64
    : m_colText(colText), m_colBack(colBack), m_font(font), m_textAlignment(alignment)
 
65
{
 
66
    m_flags = 0;
 
67
    m_leftIndent = 0;
 
68
    m_leftSubIndent = 0;
 
69
    m_rightIndent = 0;
 
70
    if (m_colText.Ok()) m_flags |= wxTEXT_ATTR_TEXT_COLOUR;
 
71
    if (m_colBack.Ok()) m_flags |= wxTEXT_ATTR_BACKGROUND_COLOUR;
 
72
    if (m_font.Ok()) m_flags |= wxTEXT_ATTR_FONT;
 
73
    if (alignment != wxTEXT_ALIGNMENT_DEFAULT)
 
74
        m_flags |= wxTEXT_ATTR_ALIGNMENT;
 
75
}
 
76
 
 
77
void wxTextAttr::Init()
 
78
{
 
79
    m_textAlignment = wxTEXT_ALIGNMENT_DEFAULT;
 
80
    m_flags = 0;
 
81
    m_leftIndent = 0;
 
82
    m_leftSubIndent = 0;
 
83
    m_rightIndent = 0;
 
84
}
 
85
 
 
86
/* static */
 
87
wxTextAttr wxTextAttr::Combine(const wxTextAttr& attr,
 
88
                               const wxTextAttr& attrDef,
 
89
                               const wxTextCtrlBase *text)
 
90
{
 
91
    wxFont font = attr.GetFont();
 
92
    if ( !font.Ok() )
 
93
    {
 
94
        font = attrDef.GetFont();
 
95
 
 
96
        if ( text && !font.Ok() )
 
97
            font = text->GetFont();
 
98
    }
 
99
 
 
100
    wxColour colFg = attr.GetTextColour();
 
101
    if ( !colFg.Ok() )
 
102
    {
 
103
        colFg = attrDef.GetTextColour();
 
104
 
 
105
        if ( text && !colFg.Ok() )
 
106
            colFg = text->GetForegroundColour();
 
107
    }
 
108
 
 
109
    wxColour colBg = attr.GetBackgroundColour();
 
110
    if ( !colBg.Ok() )
 
111
    {
 
112
        colBg = attrDef.GetBackgroundColour();
 
113
 
 
114
        if ( text && !colBg.Ok() )
 
115
            colBg = text->GetBackgroundColour();
 
116
    }
 
117
 
 
118
    wxTextAttr newAttr(colFg, colBg, font);
 
119
 
 
120
    if (attr.HasAlignment())
 
121
        newAttr.SetAlignment(attr.GetAlignment());
 
122
    else if (attrDef.HasAlignment())
 
123
        newAttr.SetAlignment(attrDef.GetAlignment());
 
124
 
 
125
    if (attr.HasTabs())
 
126
        newAttr.SetTabs(attr.GetTabs());
 
127
    else if (attrDef.HasTabs())
 
128
        newAttr.SetTabs(attrDef.GetTabs());
 
129
 
 
130
    if (attr.HasLeftIndent())
 
131
        newAttr.SetLeftIndent(attr.GetLeftIndent(), attr.GetLeftSubIndent());
 
132
    else if (attrDef.HasLeftIndent())
 
133
        newAttr.SetLeftIndent(attrDef.GetLeftIndent(), attr.GetLeftSubIndent());
 
134
 
 
135
    if (attr.HasRightIndent())
 
136
        newAttr.SetRightIndent(attr.GetRightIndent());
 
137
    else if (attrDef.HasRightIndent())
 
138
        newAttr.SetRightIndent(attrDef.GetRightIndent());
 
139
 
 
140
    return newAttr;
 
141
}
 
142
 
 
143
void wxTextAttr::operator= (const wxTextAttr& attr)
 
144
{
 
145
    m_font = attr.m_font;
 
146
    m_colText = attr.m_colText;
 
147
    m_colBack = attr.m_colBack;
 
148
    m_textAlignment = attr.m_textAlignment;
 
149
    m_leftIndent = attr.m_leftIndent;
 
150
    m_leftSubIndent = attr.m_leftSubIndent;
 
151
    m_rightIndent = attr.m_rightIndent;
 
152
    m_tabs = attr.m_tabs;
 
153
    m_flags = attr.m_flags;
 
154
}
 
155
 
 
156
 
 
157
// apply styling to text range
 
158
bool wxTextCtrlBase::SetStyle(long WXUNUSED(start), long WXUNUSED(end),
 
159
                              const wxTextAttr& WXUNUSED(style))
 
160
{
 
161
    // to be implemented in derived TextCtrl classes
 
162
    return false;
 
163
}
 
164
 
 
165
// get the styling at the given position
 
166
bool wxTextCtrlBase::GetStyle(long WXUNUSED(position), wxTextAttr& WXUNUSED(style))
 
167
{
 
168
    // to be implemented in derived TextCtrl classes
 
169
    return false;
 
170
}
 
171
 
 
172
// change default text attributes
 
173
bool wxTextCtrlBase::SetDefaultStyle(const wxTextAttr& style)
 
174
{
 
175
    // keep the old attributes if the new style doesn't specify them unless the
 
176
    // new style is empty - then reset m_defaultStyle (as there is no other way
 
177
    // to do it)
 
178
    if ( style.IsDefault() )
 
179
        m_defaultStyle = style;
 
180
    else
 
181
        m_defaultStyle = wxTextAttr::Combine(style, m_defaultStyle, this);
 
182
 
 
183
    return true;
 
184
}
 
185
 
 
186
// get default text attributes
 
187
const wxTextAttr& wxTextCtrlBase::GetDefaultStyle() const
 
188
{
 
189
    return m_defaultStyle;
 
190
}
 
191
 
 
192
// ----------------------------------------------------------------------------
 
193
// file IO functions
 
194
// ----------------------------------------------------------------------------
 
195
 
 
196
bool wxTextCtrlBase::LoadFile(const wxString& filename)
 
197
{
 
198
#if wxUSE_FFILE
 
199
    wxFFile file(filename);
 
200
    if ( file.IsOpened() )
 
201
    {
 
202
        wxString text;
 
203
        if ( file.ReadAll(&text) )
 
204
        {
 
205
            SetValue(text);
 
206
 
 
207
            DiscardEdits();
 
208
 
 
209
            m_filename = filename;
 
210
 
 
211
            return true;
 
212
        }
 
213
    }
 
214
 
 
215
    wxLogError(_("File couldn't be loaded."));
 
216
#endif // wxUSE_FFILE
 
217
 
 
218
    return false;
 
219
}
 
220
 
 
221
bool wxTextCtrlBase::SaveFile(const wxString& filename)
 
222
{
 
223
    wxString filenameToUse = filename.empty() ? m_filename : filename;
 
224
    if ( filenameToUse.empty() )
 
225
    {
 
226
        // what kind of message to give? is it an error or a program bug?
 
227
        wxLogDebug(wxT("Can't save textctrl to file without filename."));
 
228
 
 
229
        return false;
 
230
    }
 
231
 
 
232
#if wxUSE_FFILE
 
233
    wxFFile file(filenameToUse, _T("w"));
 
234
    if ( file.IsOpened() && file.Write(GetValue()) )
 
235
    {
 
236
        // it's not modified any longer
 
237
        DiscardEdits();
 
238
 
 
239
        // if it worked, save for future calls
 
240
        m_filename = filenameToUse;
 
241
 
 
242
        return true;
 
243
    }
 
244
#endif // wxUSE_FFILE
 
245
 
 
246
    wxLogError(_("The text couldn't be saved."));
 
247
 
 
248
    return false;
 
249
}
 
250
 
 
251
// ----------------------------------------------------------------------------
 
252
// stream-like insertion operator
 
253
// ----------------------------------------------------------------------------
 
254
 
 
255
wxTextCtrl& wxTextCtrlBase::operator<<(const wxString& s)
 
256
{
 
257
    AppendText(s);
 
258
    return *TEXTCTRL(this);
 
259
}
 
260
 
 
261
wxTextCtrl& wxTextCtrlBase::operator<<(float f)
 
262
{
 
263
    wxString str;
 
264
    str.Printf(wxT("%.2f"), f);
 
265
    AppendText(str);
 
266
    return *TEXTCTRL(this);
 
267
}
 
268
 
 
269
wxTextCtrl& wxTextCtrlBase::operator<<(double d)
 
270
{
 
271
    wxString str;
 
272
    str.Printf(wxT("%.2f"), d);
 
273
    AppendText(str);
 
274
    return *TEXTCTRL(this);
 
275
}
 
276
 
 
277
wxTextCtrl& wxTextCtrlBase::operator<<(int i)
 
278
{
 
279
    wxString str;
 
280
    str.Printf(wxT("%d"), i);
 
281
    AppendText(str);
 
282
    return *TEXTCTRL(this);
 
283
}
 
284
 
 
285
wxTextCtrl& wxTextCtrlBase::operator<<(long i)
 
286
{
 
287
    wxString str;
 
288
    str.Printf(wxT("%ld"), i);
 
289
    AppendText(str);
 
290
    return *TEXTCTRL(this);
 
291
}
 
292
 
 
293
wxTextCtrl& wxTextCtrlBase::operator<<(const wxChar c)
 
294
{
 
295
    return operator<<(wxString(c));
 
296
}
 
297
 
 
298
// ----------------------------------------------------------------------------
 
299
// streambuf methods implementation
 
300
// ----------------------------------------------------------------------------
 
301
 
 
302
#if wxHAS_TEXT_WINDOW_STREAM
 
303
 
 
304
int wxTextCtrlBase::overflow(int c)
 
305
{
 
306
    AppendText((wxChar)c);
 
307
 
 
308
    // return something different from EOF
 
309
    return 0;
 
310
}
 
311
 
 
312
#endif // wxHAS_TEXT_WINDOW_STREAM
 
313
 
 
314
// ----------------------------------------------------------------------------
 
315
// clipboard stuff
 
316
// ----------------------------------------------------------------------------
 
317
 
 
318
bool wxTextCtrlBase::CanCopy() const
 
319
{
 
320
    // can copy if there's a selection
 
321
    long from, to;
 
322
    GetSelection(&from, &to);
 
323
    return from != to;
 
324
}
 
325
 
 
326
bool wxTextCtrlBase::CanCut() const
 
327
{
 
328
    // can cut if there's a selection and if we're not read only
 
329
    return CanCopy() && IsEditable();
 
330
}
 
331
 
 
332
bool wxTextCtrlBase::CanPaste() const
 
333
{
 
334
    // can paste if we are not read only
 
335
    return IsEditable();
 
336
}
 
337
 
 
338
// ----------------------------------------------------------------------------
 
339
// emulating key presses
 
340
// ----------------------------------------------------------------------------
 
341
 
 
342
#ifdef __WIN32__
 
343
// the generic version is unused in wxMSW
 
344
bool wxTextCtrlBase::EmulateKeyPress(const wxKeyEvent& WXUNUSED(event))
 
345
{
 
346
    return false;
 
347
}
 
348
#else // !__WIN32__
 
349
bool wxTextCtrlBase::EmulateKeyPress(const wxKeyEvent& event)
 
350
{
 
351
    wxChar ch = 0;
 
352
    int keycode = event.GetKeyCode();
 
353
    switch ( keycode )
 
354
    {
 
355
        case WXK_NUMPAD0:
 
356
        case WXK_NUMPAD1:
 
357
        case WXK_NUMPAD2:
 
358
        case WXK_NUMPAD3:
 
359
        case WXK_NUMPAD4:
 
360
        case WXK_NUMPAD5:
 
361
        case WXK_NUMPAD6:
 
362
        case WXK_NUMPAD7:
 
363
        case WXK_NUMPAD8:
 
364
        case WXK_NUMPAD9:
 
365
            ch = (wxChar)(_T('0') + keycode - WXK_NUMPAD0);
 
366
            break;
 
367
 
 
368
        case WXK_MULTIPLY:
 
369
        case WXK_NUMPAD_MULTIPLY:
 
370
            ch = _T('*');
 
371
            break;
 
372
 
 
373
        case WXK_ADD:
 
374
        case WXK_NUMPAD_ADD:
 
375
            ch = _T('+');
 
376
            break;
 
377
 
 
378
        case WXK_SUBTRACT:
 
379
        case WXK_NUMPAD_SUBTRACT:
 
380
            ch = _T('-');
 
381
            break;
 
382
 
 
383
        case WXK_DECIMAL:
 
384
        case WXK_NUMPAD_DECIMAL:
 
385
            ch = _T('.');
 
386
            break;
 
387
 
 
388
        case WXK_DIVIDE:
 
389
        case WXK_NUMPAD_DIVIDE:
 
390
            ch = _T('/');
 
391
            break;
 
392
 
 
393
        case WXK_DELETE:
 
394
        case WXK_NUMPAD_DELETE:
 
395
            // delete the character at cursor
 
396
            {
 
397
                const long pos = GetInsertionPoint();
 
398
                if ( pos < GetLastPosition() )
 
399
                    Remove(pos, pos + 1);
 
400
            }
 
401
            break;
 
402
 
 
403
        case WXK_BACK:
 
404
            // delete the character before the cursor
 
405
            {
 
406
                const long pos = GetInsertionPoint();
 
407
                if ( pos > 0 )
 
408
                    Remove(pos - 1, pos);
 
409
            }
 
410
            break;
 
411
 
 
412
        default:
 
413
#if wxUSE_UNICODE
 
414
            if ( event.GetUnicodeKey() )
 
415
            {
 
416
                ch = event.GetUnicodeKey();
 
417
            }
 
418
            else
 
419
#endif
 
420
            if ( keycode < 256 && keycode >= 0 && wxIsprint(keycode) )
 
421
            {
 
422
                // FIXME this is not going to work for non letters...
 
423
                if ( !event.ShiftDown() )
 
424
                {
 
425
                    keycode = wxTolower(keycode);
 
426
                }
 
427
 
 
428
                ch = (wxChar)keycode;
 
429
            }
 
430
            else
 
431
            {
 
432
                ch = _T('\0');
 
433
            }
 
434
    }
 
435
 
 
436
    if ( ch )
 
437
    {
 
438
        WriteText(ch);
 
439
 
 
440
        return true;
 
441
    }
 
442
 
 
443
    return false;
 
444
}
 
445
#endif // !__WIN32__
 
446
 
 
447
// ----------------------------------------------------------------------------
 
448
// selection and ranges
 
449
// ----------------------------------------------------------------------------
 
450
 
 
451
void wxTextCtrlBase::SelectAll()
 
452
{
 
453
    SetSelection(0, GetLastPosition());
 
454
}
 
455
 
 
456
wxString wxTextCtrlBase::GetStringSelection() const
 
457
{
 
458
    long from, to;
 
459
    GetSelection(&from, &to);
 
460
 
 
461
    return GetRange(from, to);
 
462
}
 
463
 
 
464
wxString wxTextCtrlBase::GetRange(long from, long to) const
 
465
{
 
466
    wxString sel;
 
467
    if ( from < to )
 
468
    {
 
469
        sel = GetValue().Mid(from, to - from);
 
470
    }
 
471
 
 
472
    return sel;
 
473
}
 
474
 
 
475
// do the window-specific processing after processing the update event
 
476
void wxTextCtrlBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
 
477
{
 
478
    if ( event.GetSetEnabled() )
 
479
        Enable(event.GetEnabled());
 
480
 
 
481
    if ( event.GetSetText() )
 
482
    {
 
483
        if ( event.GetText() != GetValue() )
 
484
            SetValue(event.GetText());
 
485
    }
 
486
}
 
487
 
 
488
// ----------------------------------------------------------------------------
 
489
// hit testing
 
490
// ----------------------------------------------------------------------------
 
491
 
 
492
wxTextCtrlHitTestResult
 
493
wxTextCtrlBase::HitTest(const wxPoint& pt, wxTextCoord *x, wxTextCoord *y) const
 
494
{
 
495
    // implement in terms of the other overload as the native ports typically
 
496
    // can get the position and not (x, y) pair directly (although wxUniv
 
497
    // directly gets x and y -- and so overrides this method as well)
 
498
    long pos;
 
499
    wxTextCtrlHitTestResult rc = HitTest(pt, &pos);
 
500
 
 
501
    if ( rc != wxTE_HT_UNKNOWN )
 
502
    {
 
503
        PositionToXY(pos, x, y);
 
504
    }
 
505
 
 
506
    return rc;
 
507
}
 
508
 
 
509
wxTextCtrlHitTestResult
 
510
wxTextCtrlBase::HitTest(const wxPoint& WXUNUSED(pt),
 
511
                        long * WXUNUSED(pos)) const
 
512
{
 
513
    // not implemented
 
514
    return wxTE_HT_UNKNOWN;
 
515
}
 
516
 
 
517
#else // !wxUSE_TEXTCTRL
 
518
 
 
519
// define this one even if !wxUSE_TEXTCTRL because it is also used by other
 
520
// controls (wxComboBox and wxSpinCtrl)
 
521
#include "wx/event.h"
 
522
 
 
523
DEFINE_EVENT_TYPE(wxEVT_COMMAND_TEXT_UPDATED)
 
524
 
 
525
#endif // wxUSE_TEXTCTRL/!wxUSE_TEXTCTRL