~ubuntu-branches/ubuntu/raring/xmlcopyeditor/raring

« back to all changes in this revision

Viewing changes to .pc/help.patch/src/xmlcopyeditor.cpp

  • Committer: Package Import Robot
  • Author(s): Miriam Ruiz
  • Date: 2011-12-13 03:23:38 UTC
  • mfrom: (2.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20111213032338-myalkis3ru7jxqnh
Tags: 1.2.0.6-2
* Upgraded Standards-Version from 3.8.3 to 3.9.2
* Upgraded source package to DebSrc 3
* debian/rules: Using --with-wx-config=/usr/bin/wx-config in ./configure
* debian/rules: Added targets build-indep and build-arch
* Added menu file and XMP icon

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
 * Copyright 2005-2007 Gerald Schmidt.
 
3
 *
 
4
 * This file is part of Xml Copy Editor.
 
5
 *
 
6
 * Xml Copy Editor is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 * Xml Copy Editor is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with Xml Copy Editor; if not, write to the Free Software
 
17
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include <iostream>
 
21
#include <fstream>
 
22
#include <string>
 
23
#include <wx/aboutdlg.h>
 
24
#include "xmlcopyeditor.h"
 
25
#include "readfile.h"
 
26
#include "xmldoc.h"
 
27
#include "xmlctrl.h"
 
28
#include "wraplibxml.h"
 
29
#include "xmlschemalocator.h"
 
30
#include "xsllocator.h"
 
31
#include "xmlutf8reader.h"
 
32
#include "xmlpromptgenerator.h"
 
33
#include "xmlencodingspy.h"
 
34
#include "styledialog.h"
 
35
#include "mypropertysheet.h"
 
36
#include "wraptempfilename.h"
 
37
#include "globalreplacedialog.h"
 
38
#include "replace.h"
 
39
#include "associatedialog.h"
 
40
#include "xmlassociatexsd.h"
 
41
#include "xmlassociatexsl.h"
 
42
#include "xmlassociatedtd.h"
 
43
#include "wrapdaisy.h"
 
44
#include "aboutdialog.h"
 
45
#include "pathresolver.h"
 
46
#include "locationpanel.h"
 
47
#include "insertpanel.h"
 
48
#include "xmlwordcount.h"
 
49
#include "mynotebook.h"
 
50
#include "getlinuxappdir.h"
 
51
#include "commandpanel.h"
 
52
#include "binaryfile.h"
 
53
#include "exportdialog.h"
 
54
#include <wx/aui/auibook.h>
 
55
#include <wx/richtext/richtextsymboldlg.h>
 
56
#include <wx/textctrl.h>
 
57
#include <wx/artprov.h>
 
58
#include <wx/stockitem.h>
 
59
#include <iconv.h>
 
60
 
 
61
#define ngettext wxGetTranslation
 
62
 
 
63
#ifdef NEWFINDREPLACE
 
64
#include "findreplacepanel.h"
 
65
#endif
 
66
 
 
67
#include "wrapxerces.h"
 
68
#ifndef __WXMSW__
 
69
#include "xpm/appicon.xpm"
 
70
#endif
 
71
 
 
72
BEGIN_EVENT_TABLE ( MyFrame, wxFrame )
 
73
        EVT_ACTIVATE_APP ( MyFrame::OnActivateApp )
 
74
        EVT_CLOSE ( MyFrame::OnFrameClose )
 
75
        EVT_KEY_DOWN ( MyFrame::OnKeyPressed )
 
76
        EVT_MENU ( wxID_ABOUT, MyFrame::OnAbout )
 
77
        EVT_MENU ( wxID_CLOSE, MyFrame::OnClose )
 
78
        EVT_MENU ( wxID_CLOSE_ALL, MyFrame::OnCloseAll )
 
79
        EVT_MENU ( wxID_CUT, MyFrame::OnCut )
 
80
        EVT_MENU ( wxID_COPY, MyFrame::OnCopy )
 
81
        EVT_MENU ( wxID_HELP, MyFrame::OnHelp )
 
82
        EVT_MENU ( wxID_PASTE, MyFrame::OnPaste )
 
83
        EVT_MENU ( ID_PASTE_NEW_DOCUMENT, MyFrame::OnPasteNewDocument )
 
84
        EVT_MENU ( wxID_EXIT, MyFrame::OnQuit )
 
85
        EVT_MENU ( wxID_NEW, MyFrame::OnNew )
 
86
        EVT_MENU ( wxID_OPEN, MyFrame::OnOpen )
 
87
        EVT_MENU ( wxID_SAVE, MyFrame::OnSave )
 
88
        EVT_MENU ( wxID_SAVEAS, MyFrame::OnSaveAs )
 
89
        EVT_MENU ( ID_RELOAD, MyFrame::OnReload )
 
90
        EVT_MENU ( wxID_UNDO, MyFrame::OnUndo )
 
91
        EVT_MENU ( wxID_REDO, MyFrame::OnRedo )
 
92
        EVT_MENU ( wxID_REVERT, MyFrame::OnRevert )
 
93
        EVT_MENU ( ID_INSERT_CHILD, MyFrame::OnInsertChild )
 
94
        EVT_MENU ( ID_INSERT_SIBLING, MyFrame::OnInsertSibling )
 
95
        EVT_MENU ( ID_INSERT_ENTITY, MyFrame::OnInsertEntity )
 
96
        EVT_MENU ( ID_INSERT_TWIN, MyFrame::OnInsertTwin )
 
97
        EVT_MENU ( ID_INSERT_SYMBOL, MyFrame::OnInsertSymbol )
 
98
        EVT_MENU ( ID_TOGGLE_FOLD, MyFrame::OnToggleFold )
 
99
        EVT_MENU ( ID_FOLD_ALL, MyFrame::OnFoldAll )
 
100
        EVT_MENU ( ID_UNFOLD_ALL, MyFrame::OnUnfoldAll )
 
101
        EVT_MENU ( ID_OPEN_LARGE_FILE, MyFrame::OnOpen )
 
102
        EVT_MENU ( ID_PRINT_PREVIEW, MyFrame::OnPrintPreview )
 
103
        EVT_MENU ( ID_PRINT_SETUP, MyFrame::OnPrintSetup )
 
104
        EVT_MENU ( ID_PRINT, MyFrame::OnPrint )
 
105
        EVT_MENU ( ID_WORD_COUNT, MyFrame::OnWordCount )
 
106
        EVT_MENU ( ID_IMPORT_MSWORD, MyFrame::OnImportMSWord )
 
107
        EVT_MENU ( ID_EXPORT_MSWORD, MyFrame::OnExportMSWord )
 
108
        EVT_MENU ( ID_EXPORT, MyFrame::OnExport )
 
109
        EVT_MENU ( ID_HIDE_PANE, MyFrame::OnClosePane )
 
110
        EVT_MENU ( ID_COMMAND, MyFrame::OnCommand )
 
111
        EVT_MENU ( ID_FIND, MyFrame::OnFind )
 
112
        EVT_MENU ( ID_FIND_AGAIN, MyFrame::OnFindAgain )
 
113
        EVT_MENU ( ID_GOTO, MyFrame::OnGoto )
 
114
        EVT_MENU ( ID_FEEDBACK, MyFrame::OnFeedback )
 
115
        EVT_MENU ( ID_PREVIOUS_DOCUMENT, MyFrame::OnPreviousDocument )
 
116
        EVT_MENU ( ID_NEXT_DOCUMENT, MyFrame::OnNextDocument )
 
117
        EVT_MENU ( ID_BROWSER, MyFrame::OnBrowser )
 
118
        EVT_MENU ( ID_REPLACE, MyFrame::OnFindReplace )
 
119
        EVT_MENU ( ID_GLOBAL_REPLACE, MyFrame::OnGlobalReplace )
 
120
        EVT_MENU ( ID_CHECK_WELLFORMED, MyFrame::OnCheckWellformedness )
 
121
        EVT_MENU ( ID_VALIDATE_RELAX_NG, MyFrame::OnValidateRelaxNG )
 
122
        EVT_MENU ( ID_VALIDATE_W3C_SCHEMA, MyFrame::OnValidateSchema )
 
123
        EVT_MENU ( ID_XPATH, MyFrame::OnXPath )
 
124
        EVT_MENU_RANGE ( ID_XSLT, ID_XSLT_WORDML_DOCBOOK, MyFrame::OnXslt )
 
125
        EVT_MENU ( ID_PRETTYPRINT, MyFrame::OnPrettyPrint )
 
126
        EVT_MENU ( ID_ENCODING, MyFrame::OnEncoding )
 
127
        EVT_MENU ( ID_STYLE, MyFrame::OnSpelling )
 
128
        EVT_MENU ( ID_SPELL, MyFrame::OnSpelling )
 
129
        EVT_MENU ( ID_FONT_SMALLER, MyFrame::OnFontSmaller )
 
130
        EVT_MENU ( ID_FONT_NORMAL, MyFrame::OnFontMedium )
 
131
        EVT_MENU ( ID_FONT_LARGER, MyFrame::OnFontLarger )
 
132
        EVT_MENU ( ID_OPTIONS, MyFrame::OnOptions )
 
133
        EVT_MENU ( ID_HOME, MyFrame::OnHome )
 
134
        EVT_MENU ( ID_DOWNLOAD_SOURCE, MyFrame::OnDownloadSource )
 
135
        EVT_MENU ( ID_TOOLBAR_VISIBLE, MyFrame::OnToolbarVisible )
 
136
        EVT_MENU ( ID_LOCATION_PANE_VISIBLE, MyFrame::OnLocationPaneVisible )
 
137
        EVT_MENU ( ID_PROTECT_TAGS, MyFrame::OnProtectTags )
 
138
        EVT_MENU ( ID_WRAP_WORDS, MyFrame::OnWrapWords )
 
139
        EVT_MENU_RANGE ( ID_SHOW_TAGS, ID_HIDE_TAGS, MyFrame::OnVisibilityState )
 
140
        EVT_MENU_RANGE ( ID_ASSOCIATE_DTD_PUBLIC, ID_ASSOCIATE_XSL, MyFrame::OnAssociate )
 
141
        EVT_MENU_RANGE ( wxID_FILE1, wxID_FILE9, MyFrame::OnHistoryFile )
 
142
        EVT_MENU_RANGE (
 
143
            ID_VALIDATE_PRESET1, ID_VALIDATE_PRESET9, MyFrame::OnValidatePreset )
 
144
        EVT_MENU_RANGE (
 
145
            ID_COLOR_SCHEME_DEFAULT,
 
146
            ID_COLOR_SCHEME_NONE,
 
147
            MyFrame::OnColorScheme )
 
148
        
 
149
        EVT_MENU_RANGE (
 
150
            ID_SPLIT_TAB_TOP,
 
151
            ID_SPLIT_TAB_LEFT,
 
152
            MyFrame::OnSplitTab )
 
153
        
 
154
        EVT_UPDATE_UI_RANGE ( ID_REPLACE, ID_GLOBAL_REPLACE, MyFrame::OnUpdateReplaceRange )
 
155
        EVT_FIND ( wxID_ANY, MyFrame::OnDialogFind )
 
156
        EVT_FIND_NEXT ( wxID_ANY, MyFrame::OnDialogFind )
 
157
        EVT_FIND_REPLACE ( wxID_ANY, MyFrame::OnDialogReplace )
 
158
        EVT_FIND_REPLACE_ALL ( wxID_ANY, MyFrame::OnDialogReplaceAll )
 
159
        EVT_ICONIZE ( MyFrame::OnIconize )
 
160
        EVT_UPDATE_UI ( ID_LOCATION_PANE_VISIBLE, MyFrame::OnUpdateLocationPaneVisible )
 
161
        EVT_UPDATE_UI ( wxID_CLOSE, MyFrame::OnUpdateDocRange )
 
162
        EVT_UPDATE_UI ( wxID_SAVEAS, MyFrame::OnUpdateDocRange )
 
163
        EVT_UPDATE_UI ( wxID_CLOSE_ALL, MyFrame::OnUpdateCloseAll )
 
164
        EVT_UPDATE_UI_RANGE ( ID_SPLIT_TAB_TOP, ID_SPLIT_TAB_LEFT, MyFrame::OnUpdateCloseAll )
 
165
        EVT_UPDATE_UI ( wxID_REVERT, MyFrame::OnUpdateUndo )
 
166
        EVT_UPDATE_UI ( wxID_SAVE, MyFrame::OnUpdateDocRange ) // always allow save if doc present
 
167
        EVT_UPDATE_UI ( wxID_UNDO, MyFrame::OnUpdateUndo )
 
168
        EVT_UPDATE_UI ( wxID_REDO, MyFrame::OnUpdateRedo )
 
169
        EVT_UPDATE_UI ( wxID_PASTE, MyFrame::OnUpdatePaste )
 
170
        EVT_UPDATE_UI ( wxID_CUT, MyFrame::OnUpdateCutCopy )
 
171
        EVT_UPDATE_UI ( wxID_COPY, MyFrame::OnUpdateCutCopy )
 
172
        EVT_UPDATE_UI ( ID_FIND_AGAIN, MyFrame::OnUpdateFindAgain )
 
173
        EVT_UPDATE_UI_RANGE ( ID_FIND, ID_EXPORT_MSWORD, MyFrame::OnUpdateDocRange )
 
174
        EVT_UPDATE_UI ( ID_PREVIOUS_DOCUMENT, MyFrame::OnUpdatePreviousDocument )
 
175
        EVT_UPDATE_UI ( ID_NEXT_DOCUMENT, MyFrame::OnUpdateNextDocument )
 
176
        EVT_UPDATE_UI ( ID_HIDE_PANE, MyFrame::OnUpdateClosePane )
 
177
        EVT_UPDATE_UI ( ID_RELOAD, MyFrame::OnUpdateReload )
 
178
        EVT_IDLE ( MyFrame::OnIdle )
 
179
        EVT_AUINOTEBOOK_PAGE_CLOSE ( wxID_ANY, MyFrame::OnPageClosing )
 
180
#ifdef __WXMSW__
 
181
        EVT_DROP_FILES ( MyFrame::OnDropFiles )
 
182
#endif
 
183
END_EVENT_TABLE()
 
184
 
 
185
IMPLEMENT_APP ( MyApp)
 
186
 
 
187
MyApp::MyApp() : checker ( NULL ), server ( NULL ), connection ( NULL ),
 
188
#ifdef __WXMSW__
 
189
       config ( new wxFileConfig ( _T ( ".xmlcopyeditor" ) ) )//( _T ( "SourceForge Project\\XML Copy Editor" ) ) )
 
190
#else
 
191
                config ( new wxFileConfig ( _T ( "xmlcopyeditor" ) ) )
 
192
#endif
 
193
{
 
194
        lang = 0;
 
195
 
 
196
#ifdef __WXGTK__
 
197
        int fdnull = open ( "/dev/null", O_WRONLY, 0 );
 
198
        dup2 ( fdnull, STDERR_FILENO );
 
199
#endif
 
200
        myLocale.Init();
 
201
        int systemLocale = myLocale.GetSystemLanguage();
 
202
        switch ( systemLocale )
 
203
        {
 
204
                case wxLANGUAGE_GERMAN:
 
205
                case wxLANGUAGE_GERMAN_AUSTRIAN:
 
206
                case wxLANGUAGE_GERMAN_BELGIUM:
 
207
                case wxLANGUAGE_GERMAN_LIECHTENSTEIN:
 
208
                case wxLANGUAGE_GERMAN_LUXEMBOURG:
 
209
                case wxLANGUAGE_GERMAN_SWISS:
 
210
                        systemLocale = wxLANGUAGE_GERMAN;
 
211
                        break;
 
212
                case wxLANGUAGE_CHINESE_SIMPLIFIED:
 
213
                        systemLocale = wxLANGUAGE_CHINESE_SIMPLIFIED;
 
214
                        break;
 
215
                case wxLANGUAGE_CHINESE_TRADITIONAL:
 
216
                        systemLocale = wxLANGUAGE_CHINESE_TRADITIONAL;
 
217
                        break;
 
218
                case wxLANGUAGE_CATALAN:
 
219
            systemLocale = wxLANGUAGE_CATALAN;
 
220
            break;
 
221
                case wxLANGUAGE_SPANISH:
 
222
                case wxLANGUAGE_SPANISH_ARGENTINA:
 
223
                case wxLANGUAGE_SPANISH_BOLIVIA:
 
224
                case wxLANGUAGE_SPANISH_CHILE:
 
225
                case wxLANGUAGE_SPANISH_COLOMBIA:
 
226
                case wxLANGUAGE_SPANISH_COSTA_RICA:
 
227
                case wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC:
 
228
                case wxLANGUAGE_SPANISH_ECUADOR:
 
229
                case wxLANGUAGE_SPANISH_EL_SALVADOR:
 
230
                case wxLANGUAGE_SPANISH_GUATEMALA:
 
231
                case wxLANGUAGE_SPANISH_HONDURAS:
 
232
                case wxLANGUAGE_SPANISH_MEXICAN:
 
233
                case wxLANGUAGE_SPANISH_MODERN:
 
234
                case wxLANGUAGE_SPANISH_NICARAGUA:
 
235
                case wxLANGUAGE_SPANISH_PANAMA:
 
236
                case wxLANGUAGE_SPANISH_PARAGUAY:
 
237
                case wxLANGUAGE_SPANISH_PERU:
 
238
                case wxLANGUAGE_SPANISH_PUERTO_RICO:
 
239
                case wxLANGUAGE_SPANISH_URUGUAY:
 
240
                case wxLANGUAGE_SPANISH_US:
 
241
                case wxLANGUAGE_SPANISH_VENEZUELA:
 
242
                        systemLocale = wxLANGUAGE_SPANISH;
 
243
                        break;
 
244
                case wxLANGUAGE_SLOVAK:
 
245
                        systemLocale = wxLANGUAGE_SLOVAK;
 
246
                        break;
 
247
                case wxLANGUAGE_SWEDISH:
 
248
                        systemLocale = wxLANGUAGE_SWEDISH;
 
249
                        break;
 
250
                case wxLANGUAGE_FRENCH:
 
251
                        systemLocale = wxLANGUAGE_FRENCH;
 
252
                        break;
 
253
                case wxLANGUAGE_UKRAINIAN:
 
254
                        systemLocale = wxLANGUAGE_UKRAINIAN;
 
255
                        break;
 
256
                case wxLANGUAGE_ITALIAN:
 
257
                        systemLocale = wxLANGUAGE_ITALIAN;
 
258
                        break;
 
259
                case wxLANGUAGE_RUSSIAN:
 
260
                        systemLocale = wxLANGUAGE_RUSSIAN;
 
261
                        break;
 
262
                case wxLANGUAGE_DUTCH:
 
263
                        systemLocale = wxLANGUAGE_DUTCH;
 
264
                        break;
 
265
                default:
 
266
                        systemLocale = wxLANGUAGE_ENGLISH_US;
 
267
                        break;
 
268
        }
 
269
 
 
270
        if ( config.get() )
 
271
        {
 
272
#ifdef __WXMSW__
 
273
                singleInstanceCheck = config->Read ( _T ( "singleInstanceCheck" ), true );
 
274
#else
 
275
                long longFalse = 0;
 
276
                singleInstanceCheck = config->Read ( _T ( "singleInstanceCheck" ), longFalse );
 
277
#endif
 
278
                lang = config->Read ( _T ( "lang" ), systemLocale );
 
279
        }
 
280
        else
 
281
        {
 
282
                lang = systemLocale;
 
283
#ifdef __WXMSW__
 
284
                singleInstanceCheck = true;
 
285
#else
 
286
                singleInstanceCheck = false;
 
287
#endif
 
288
        }
 
289
 
 
290
        myLocale.Init ( lang, wxLOCALE_LOAD_DEFAULT );
 
291
        wxLocale::AddCatalogLookupPathPrefix ( wxT ( "." ) );
 
292
        wxLocale::AddCatalogLookupPathPrefix ( wxT ( ".." ) );
 
293
 
 
294
#ifndef __WXMSW__
 
295
        wxString poDir = GetLinuxAppDir::run() + wxFileName::GetPathSeparator() + _T ( "po" ) + wxFileName::GetPathSeparator();
 
296
        wxLocale::AddCatalogLookupPathPrefix ( poDir );
 
297
#endif
 
298
 
 
299
        if ( !myLocale.AddCatalog ( _T ( "messages" ) ) )
 
300
                ;
 
301
 
 
302
#ifndef __WXMSW__
 
303
        {
 
304
                wxLogNull noLog;
 
305
                myLocale.AddCatalog ( _T ( "fileutils" ) );
 
306
        }
 
307
#endif
 
308
}
 
309
 
 
310
MyApp::~MyApp()
 
311
{
 
312
        delete checker;
 
313
        delete server;
 
314
        delete connection;
 
315
}
 
316
 
 
317
bool MyApp::OnInit()
 
318
{
 
319
 
 
320
        wxString name, service, hostName;
 
321
        name.Printf ( _T ( "xmlcopyeditor-%s" ), wxGetUserId().c_str() );
 
322
        service = IPC_SERVICE;
 
323
        hostName = _T ( "localhost" );
 
324
 
 
325
        if ( singleInstanceCheck )
 
326
        {
 
327
        checker = new wxSingleInstanceChecker ( name );
 
328
                while ( checker->IsAnotherRunning() )
 
329
                {
 
330
                        // attempt calling server
 
331
                        client = new MyClient();
 
332
                        connection = ( MyClientConnection * )
 
333
                                     client->MakeConnection ( hostName, service, IPC_TOPIC );
 
334
                        if ( !connection || !connection->StartAdvise ( IPC_ADVISE_NAME ) )
 
335
                                break;
 
336
                        else
 
337
                        {
 
338
                                wxString argument, what;
 
339
                                wxChar *whatBuffer;
 
340
                                what = _T ( "Data" );
 
341
                                whatBuffer = (wxChar *)what.c_str();
 
342
                                if ( this->argc > 1 )
 
343
                                {
 
344
                                        for ( int i = 1; i < this->argc; i++ )
 
345
                                        {
 
346
                                                argument = ( wxString ) this->argv[i];
 
347
                                                argument = PathResolver::run ( argument );
 
348
                                                if ( ! connection->Poke ( argument, whatBuffer ) )
 
349
                                                   break;
 
350
                                        }
 
351
                                }
 
352
                                else
 
353
                                {
 
354
                                        argument = ( wxString ) IPC_NO_FILE;
 
355
                                        connection->Poke ( argument, whatBuffer );
 
356
                                }
 
357
                                return false;
 
358
                        }
 
359
                }
 
360
        }
 
361
 
 
362
        server = new MyServer;
 
363
        server->Create ( service );
 
364
 
 
365
        MyFrame *frame;
 
366
        try
 
367
        {
 
368
                wxImage::AddHandler ( new wxPNGHandler );
 
369
                wxSystemOptions::SetOption ( _T ( "msw.remap" ), 0 );
 
370
                frame = new MyFrame (
 
371
                    _ ( "XML Copy Editor" ),
 
372
                    config.get(),
 
373
                    myLocale,
 
374
                    singleInstanceCheck,
 
375
                    lang );
 
376
                frame->Show ( true );
 
377
                if ( frame->getHandleCommandLineFlag() )
 
378
                        frame->handleCommandLine();
 
379
        }
 
380
        catch ( exception &e )
 
381
        {
 
382
                const char *what;
 
383
                what = e.what();
 
384
                wxString wideWhat, errorString;
 
385
                wideWhat = wxString ( what, wxConvLocal, strlen ( what ) );
 
386
 
 
387
                if ( wideWhat.empty() )
 
388
                        wideWhat = _ ( "(unknown error)" );
 
389
 
 
390
                errorString = _ ( "XML Copy Editor has encountered the following error and needs to close: " );
 
391
                errorString += wideWhat;
 
392
                errorString += _T ( "." );
 
393
#ifdef __WXMSW__
 
394
                ::MessageBox (
 
395
                    NULL,
 
396
                    errorString,
 
397
                    _ ( "Error" ),
 
398
                    MB_ICONERROR | MB_TASKMODAL );
 
399
#else
 
400
                wxMessageBox ( errorString, _ ( "Error" ), wxICON_ERROR );
 
401
#endif
 
402
                exit ( EXIT_FAILURE );
 
403
        }
 
404
        catch ( ... )
 
405
        {
 
406
                exit ( EXIT_FAILURE );
 
407
        }
 
408
        return true;
 
409
}
 
410
 
 
411
void MyApp::OnUnhandledException()
 
412
{
 
413
#ifdef __WXMSW__
 
414
        ::MessageBox (
 
415
            NULL,
 
416
            _ ( "XML Copy Editor has encountered an error and needs to close." ),
 
417
            _ ( "Error" ),
 
418
            MB_ICONERROR | MB_TASKMODAL );
 
419
#else
 
420
        wxMessageBox (
 
421
            _ ( "XML Copy Editor has encountered an error and needs to close." ),
 
422
            _ ( "Error" ),
 
423
            wxICON_ERROR );
 
424
#endif
 
425
        exit ( EXIT_FAILURE );
 
426
}
 
427
 
 
428
bool MyApp::OnExceptionInMainLoop()
 
429
{
 
430
        try
 
431
        {
 
432
                throw;
 
433
        }
 
434
#ifdef __WXMSW__
 
435
        catch ( bad_alloc& )
 
436
        {
 
437
                ::MessageBox (
 
438
                    NULL,
 
439
                    _ ( "The operating system has turned down a request for additional memory" ),
 
440
                    _ ( "Out of memory" ),
 
441
                    MB_ICONERROR );
 
442
                return true;
 
443
        }
 
444
#endif
 
445
        catch ( exception &e )
 
446
        {
 
447
                const char *what;
 
448
                what = e.what();
 
449
                wxString wideWhat, errorString;
 
450
                wideWhat = wxString ( what, wxConvLocal, strlen ( what ) );
 
451
 
 
452
                if ( wideWhat.empty() )
 
453
                        _ ( "(unknown error)" );
 
454
 
 
455
                errorString = _ ( "The following error has occurred: " );
 
456
                errorString += wideWhat;
 
457
                errorString += _ ( ".\n\nSelect \"Abort\" to exit, \"Retry\" to close this window and \"Ignore\" to continue." );
 
458
#ifdef __WXMSW__
 
459
                int ret = ::MessageBox (
 
460
                              NULL,
 
461
                              errorString,
 
462
                              _ ( "Error" ),
 
463
                              MB_ABORTRETRYIGNORE |
 
464
                              MB_ICONERROR |
 
465
                              MB_TASKMODAL );
 
466
                switch ( ret )
 
467
                {
 
468
                        case IDABORT:
 
469
                                exit ( EXIT_FAILURE );
 
470
                                break;
 
471
                        case IDRETRY:
 
472
                                return false;
 
473
                        case IDIGNORE:
 
474
                                return true;
 
475
                        default:
 
476
                                throw;
 
477
                }
 
478
#else
 
479
                // wxGTK does not reach this point; see HandleEvent below
 
480
                wxMessageBox (
 
481
                    errorString,
 
482
                    _ ( "Error" ),
 
483
                    wxICON_ERROR );
 
484
                return false;
 
485
#endif
 
486
        }
 
487
        catch ( ... )
 
488
        {
 
489
                wxString otherError ( _ ( "XML Copy Editor has encountered an error and needs to close." ) );
 
490
#ifdef __WXMSW__
 
491
                ::MessageBox (
 
492
                    NULL,
 
493
                    otherError,
 
494
                    _ ( "Error" ),
 
495
                    MB_ICONERROR );
 
496
                return false;
 
497
#else
 
498
                wxMessageBox (
 
499
                    otherError,
 
500
                    _ ( "Error" ),
 
501
                    wxICON_ERROR );
 
502
                return false;
 
503
#endif
 
504
        }
 
505
        return false;
 
506
}
 
507
 
 
508
#ifndef __WXMSW__
 
509
void MyApp::HandleEvent ( wxEvtHandler *handler, wxEventFunction func, wxEvent& event ) const
 
510
{
 
511
        try
 
512
        {
 
513
                wxApp::HandleEvent ( handler, func, event );
 
514
        }
 
515
        catch ( std::bad_alloc& )
 
516
        {
 
517
                wxMessageBox (
 
518
                    _ ( "The operating system has turned down a request for additional memory" ),
 
519
                    _ ( "Out of memory" ),
 
520
                    wxICON_ERROR );
 
521
                return;
 
522
        }
 
523
        catch ( std::exception& e )
 
524
        {
 
525
                std::string s ( e.what() );
 
526
                wxString ws = wxString ( s.c_str(), wxConvUTF8, s.size() );
 
527
                wxMessageBox (
 
528
                    ws,
 
529
                    _ ( "Error" ),
 
530
                    wxICON_ERROR );
 
531
                return;
 
532
        }
 
533
        catch ( ... )
 
534
        {
 
535
                throw;
 
536
        }
 
537
}
 
538
#endif
 
539
 
 
540
MyFrame::MyFrame (
 
541
    const wxString& title,
 
542
    wxFileConfig *configParameter,
 
543
    wxLocale& locale,
 
544
    bool singleInstanceCheckParameter,
 
545
    int langParameter ) :
 
546
                wxFrame ( NULL, wxID_ANY, title ),
 
547
                config ( configParameter ),
 
548
                myLocale ( locale ),
 
549
                singleInstanceCheck ( singleInstanceCheckParameter ),
 
550
                lang ( langParameter ),
 
551
                htmlPrinting ( new wxHtmlEasyPrinting (
 
552
                                   wxEmptyString,
 
553
                                   this ) ),
 
554
                findDialog ( 0 ),
 
555
#ifndef __WXMSW__
 
556
                helpController ( new wxHtmlHelpController() ),
 
557
#endif
 
558
                menuBar ( 0 ),
 
559
                toolBar ( 0 ),
 
560
                xmlMenu ( 0 ),
 
561
                mainBook ( 0 ),
 
562
                restoreFocusToNotebook ( false )
 
563
{
 
564
        manager.SetManagedWindow ( this );
 
565
 
 
566
        lastPos = 0;
 
567
        htmlReport = NULL;
 
568
        lastDoc = NULL;
 
569
 
 
570
        wxString defaultFont =
 
571
#ifdef __WXMSW__
 
572
            _T ( "Arial" );
 
573
#else
 
574
            _T ( "Bitstream Vera Sans" );
 
575
#endif
 
576
 
 
577
        bool findMatchCase;
 
578
 
 
579
        // fetch configuration
 
580
        if ( config ) // config found
 
581
        {
 
582
                history.Load ( *config );
 
583
                properties.insertCloseTag =
 
584
                    config->Read ( _T ( "insertCloseTag" ), true );
 
585
                properties.completion =
 
586
                    config->Read ( _T ( "completion" ), true );
 
587
                properties.number =
 
588
                    config->Read ( _T ( "number" ), true );
 
589
                properties.fold =
 
590
                    config->Read ( _T ( "fold" ), true );
 
591
                properties.currentLine =
 
592
                    config->Read ( _T ( "currentLine" ), true );
 
593
                properties.highlightSyntax =
 
594
                    config->Read ( _T ( "highlightSyntax" ), true );
 
595
                properties.whitespaceVisible =
 
596
                    config->Read ( _T ( "whitespaceVisible" ), true );
 
597
                properties.indentLines =
 
598
                    config->Read ( _T ( "indentLines" ), true );
 
599
                properties.toggleLineBackground =
 
600
                    config->Read ( _T ( "toggleLineBackground" ), true );
 
601
                properties.protectHiddenElements =
 
602
                    config->Read ( _T ( "protectHiddenElements" ), true );
 
603
                properties.deleteWholeTag =
 
604
                    config->Read ( _T ( "deleteWholeTag" ), true );
 
605
                properties.validateAsYouType =
 
606
                    config->Read ( _T ( "validateAsYouType" ), true );
 
607
                properties.font =
 
608
                    config->Read ( _T ( "font" ), defaultFont );
 
609
                findRegex =
 
610
                    config->Read ( _T ( "findRegex" ), true );
 
611
                xpathExpression =
 
612
                    config->Read ( _T ( "xpathExpression" ), wxEmptyString );
 
613
                lastXslStylesheet =
 
614
                    config->Read ( _T ( "lastXslStylesheet" ), wxEmptyString );
 
615
                lastRelaxNGSchema =
 
616
                    config->Read ( _T ( "lastRelaxNGSchema" ), wxEmptyString );
 
617
 
 
618
                lastXslStylesheet.Replace ( _T ( " " ), _T ( "%20" ), true );
 
619
                lastRelaxNGSchema.Replace ( _T ( " " ), _T ( "%20" ), true );
 
620
                
 
621
                exportQuiet =
 
622
                  config->Read ( _T ( "exportQuiet" ), (long)false );
 
623
                exportMp3Album =
 
624
                  config->Read ( _T ( "exportMp3Album" ), (long)false );
 
625
                
 
626
 
 
627
                applicationDir =
 
628
                    config->Read ( _T ( "applicationDir" ), wxEmptyString );
 
629
                if ( applicationDir.empty() )
 
630
                {
 
631
#ifdef __WXMSW__
 
632
                        applicationDir =
 
633
                            config->Read ( _T ( "InstallPath" ), wxGetCwd() );
 
634
#else
 
635
                        applicationDir = GetLinuxAppDir::run();
 
636
#endif
 
637
                }
 
638
                browserCommand =
 
639
                    config->Read ( _T ( "browserCommand" ), wxEmptyString );
 
640
 
 
641
                // if default value != true, type as long int
 
642
                long valZoom, longFalse;
 
643
                longFalse = false;
 
644
                valZoom = 0;
 
645
                frameWidth = frameHeight = framePosX = framePosY = 0;
 
646
 
 
647
                properties.wrap =
 
648
                    config->Read ( _T ( "wrap" ), longFalse );
 
649
 
 
650
                properties.zoom =
 
651
                    config->Read ( _T ( "zoom" ), valZoom );
 
652
 
 
653
                properties.colorScheme = config->Read ( _T ( "colorScheme" ), COLOR_SCHEME_DEFAULT );
 
654
 
 
655
                globalReplaceAllDocuments =
 
656
                    config->Read ( _T ( "globalReplaceAllDocuments" ), longFalse );
 
657
                showFullPathOnFrame =
 
658
                    config->Read ( _T ( "showFullPathOnFrame" ), longFalse );
 
659
                findMatchCase =
 
660
                    config->Read ( _T ( "findMatchCase" ), longFalse );
 
661
 
 
662
                commandSync = config->Read ( _T ( "commandSync" ), longFalse );
 
663
                commandOutput = config->Read ( _T ( "commandOutput" ), ID_COMMAND_OUTPUT_IGNORE );
 
664
                commandString = config->Read ( _T ( "commandString" ), wxEmptyString );
 
665
                
 
666
                exportStylesheet = config->Read ( _T ( "exportStylesheet" ), wxEmptyString );
 
667
                exportFolder = config->Read ( _T ( "exportFolder" ), wxEmptyString );
 
668
 
 
669
                ruleSetPreset =
 
670
                    config->Read ( _T ( "ruleSetPreset" ), _ ( "Default style" ) );
 
671
                dictionaryPreset = 
 
672
                    config->Read ( _T ( "dictionaryPreset" ), _ ( "en_US" ) );
 
673
                
 
674
                filterPreset =
 
675
                    config->Read ( _T ( "filterPreset" ), _ ( "(No filter)" ) );
 
676
                findData.SetFindString ( config->Read ( _T ( "findReplaceFind" ), _T ( "" ) ) );
 
677
                findData.SetReplaceString ( config->Read ( _T ( "findReplaceReplace" ), _T ( "" ) ) );
 
678
 
 
679
                toolbarVisible =
 
680
                    config->Read ( _T ( "toolbarVisible" ), true );
 
681
                protectTags = config->Read ( _T ( "protectTags" ), longFalse );
 
682
                visibilityState = config->Read ( _T ( "visibilityState" ), ID_SHOW_TAGS );
 
683
 
 
684
                framePosX = config->Read ( _T ( "framePosX" ), framePosX );
 
685
                framePosY = config->Read ( _T ( "framePosY" ), framePosY );
 
686
                frameWidth = config->Read ( _T ( "frameWidth" ), frameWidth );
 
687
                frameHeight = config->Read ( _T ( "frameHeight" ), frameHeight );
 
688
                rememberOpenTabs = config->Read ( _T ( "rememberOpenTabs" ), true );
 
689
                libxmlNetAccess = config->Read ( _T ( "libxmlNetAccess" ), longFalse );
 
690
                openTabsOnClose = config->Read ( _T ( "openTabsOnClose" ), _T ( "" ) );
 
691
                notebookStyle = config->Read ( _T ( "notebookStyle" ), ID_NOTEBOOK_STYLE_VC8_COLOR );
 
692
                saveBom = config->Read ( _T ( "saveBom" ), true );
 
693
                unlimitedUndo = config->Read ( _T ( "unlimitedUndo" ), true );
 
694
                layout = config->Read ( _T ( "layout" ), wxEmptyString );
 
695
                restoreLayout = config->Read ( _T ( "restoreLayout" ), true );
 
696
                showLocationPane = config->Read ( _T ( "showLocationPane" ), true );
 
697
                showInsertChildPane = config->Read ( _T ( "showInsertChildPane" ), true );
 
698
                showInsertSiblingPane = config->Read ( _T ( "showInsertSiblingPane" ), true );
 
699
                showInsertEntityPane = config->Read ( _T ( "showInsertEntityPane" ), true );
 
700
                expandInternalEntities = config->Read ( _T ( "expandInternalEntities" ), true );
 
701
 
 
702
        }
 
703
        else // config not found
 
704
        {
 
705
                properties.insertCloseTag =
 
706
                    properties.completion =
 
707
                        properties.currentLine =
 
708
                            properties.indentLines =
 
709
                                properties.protectHiddenElements =
 
710
                                    properties.toggleLineBackground =
 
711
                                        properties.deleteWholeTag =
 
712
                                            properties.highlightSyntax = true;
 
713
                properties.font = defaultFont;
 
714
                properties.wrap = properties.whitespaceVisible = false;
 
715
                properties.zoom = 0;
 
716
                properties.colorScheme = COLOR_SCHEME_DEFAULT;
 
717
#ifdef __WXMSW__
 
718
                applicationDir = wxGetCwd();
 
719
#else
 
720
                applicationDir = GetLinuxAppDir::run();//getLinuxApplicationDir();
 
721
#endif
 
722
                ruleSetPreset = _ ( "Default style" );
 
723
                dictionaryPreset = _ ( "en_US" );
 
724
                filterPreset = _ ( "No filter" );
 
725
                xpathExpression = lastXslStylesheet = lastRelaxNGSchema = wxEmptyString;
 
726
                findRegex = true;
 
727
                findMatchCase = globalReplaceAllDocuments =
 
728
                                    showFullPathOnFrame = false;
 
729
                toolbarVisible = true;
 
730
                protectTags = false;
 
731
                visibilityState = SHOW_TAGS;
 
732
                framePosX = framePosY = frameWidth = frameHeight = 0;
 
733
                rememberOpenTabs = true;
 
734
                libxmlNetAccess = false;
 
735
                openTabsOnClose = wxEmptyString;
 
736
                browserCommand = wxEmptyString;
 
737
                notebookStyle = ID_NOTEBOOK_STYLE_VC8_COLOR;
 
738
                saveBom = unlimitedUndo = true;
 
739
                layout = wxEmptyString;
 
740
                restoreLayout = true;
 
741
                showLocationPane = true;
 
742
                showInsertChildPane = true;
 
743
                showInsertSiblingPane = true;
 
744
                showInsertEntityPane = true;
 
745
                expandInternalEntities = true;
 
746
                properties.validateAsYouType = true;
 
747
 
 
748
                commandSync = false;
 
749
                commandOutput = ID_COMMAND_OUTPUT_IGNORE;
 
750
                commandString = wxEmptyString;
 
751
                
 
752
                exportStylesheet = exportFolder = wxEmptyString;
 
753
                exportQuiet = exportMp3Album = false;
 
754
 
 
755
        }
 
756
 
 
757
        largeFileProperties.completion = false;
 
758
        largeFileProperties.fold = false;
 
759
        largeFileProperties.whitespaceVisible = false;
 
760
        largeFileProperties.wrap = false;
 
761
        largeFileProperties.indentLines = false;
 
762
        largeFileProperties.protectHiddenElements = false;
 
763
        largeFileProperties.toggleLineBackground = false;
 
764
        largeFileProperties.toggleLineBackground = false;
 
765
        largeFileProperties.insertCloseTag = false;
 
766
        largeFileProperties.deleteWholeTag = false;
 
767
        largeFileProperties.highlightSyntax = false;
 
768
        largeFileProperties.validateAsYouType = false;
 
769
        largeFileProperties.number = properties.number;
 
770
        largeFileProperties.currentLine = properties.currentLine;
 
771
        largeFileProperties.font = properties.font;
 
772
        largeFileProperties.zoom = 0;
 
773
        largeFileProperties.colorScheme = COLOR_SCHEME_NONE;
 
774
 
 
775
        updatePaths();
 
776
        loadBitmaps();
 
777
 
 
778
        size_t findFlags = 0;
 
779
        findFlags |= wxFR_DOWN;
 
780
 
 
781
        if ( findMatchCase )
 
782
                findFlags |= wxFR_MATCHCASE;
 
783
 
 
784
        findData.SetFlags ( findFlags );
 
785
 
 
786
        if ( browserCommand.empty() )
 
787
        {
 
788
#ifdef __WXMSW__
 
789
                browserCommand = binDir + _T ( "navigate.exe" );
 
790
#else
 
791
                browserCommand = getLinuxBrowser();
 
792
#endif
 
793
        }
 
794
 
 
795
        // initialise document count for tab labels
 
796
        documentCount = 1;
 
797
 
 
798
        SetIcon ( wxICON ( appicon ) );
 
799
 
 
800
        CreateStatusBar();
 
801
        wxStatusBar *status = GetStatusBar();
 
802
        int widths[] = { -24, -6, -6, -6, -8 };
 
803
        status->SetFieldsCount ( 5 );
 
804
        status->SetStatusWidths ( 5, widths );
 
805
 
 
806
        if ( !frameWidth ||
 
807
                !frameHeight ||
 
808
                frameWidth < 0 ||
 
809
                frameHeight < 0 ||
 
810
                framePosX < 0 ||
 
811
                framePosY < 0 )
 
812
        {
 
813
#ifdef __WXMSW__
 
814
                Maximize();
 
815
#else
 
816
                SetSize ( 50, 50, 640, 480 );
 
817
#endif
 
818
        }
 
819
        else
 
820
        {
 
821
                SetSize ( framePosX, framePosY, frameWidth, frameHeight );
 
822
        }
 
823
 
 
824
        stylePosition = aboutPosition = wxDefaultPosition;
 
825
        styleSize = wxSize ( 720, 540 );
 
826
 
 
827
        showTopBars ( toolbarVisible );
 
828
 
 
829
        long style = wxAUI_NB_TOP |
 
830
                     wxAUI_NB_TAB_SPLIT |
 
831
                     wxAUI_NB_TAB_MOVE |
 
832
                     wxAUI_NB_WINDOWLIST_BUTTON |
 
833
                     wxAUI_NB_CLOSE_ON_ALL_TABS |
 
834
                     wxNO_BORDER;
 
835
 
 
836
        mainBook = new MyNotebook (
 
837
            this,
 
838
            ID_NOTEBOOK,
 
839
            wxDefaultPosition,
 
840
            wxDefaultSize,
 
841
            style );
 
842
 
 
843
        manager.AddPane ( mainBook, wxAuiPaneInfo().CenterPane()
 
844
                          .PaneBorder ( false ).Name ( _T ( "documentPane" ) ) );
 
845
        manager.GetPane ( mainBook ).dock_proportion = 10;
 
846
 
 
847
        // add insert child panes
 
848
        locationPanel = new LocationPanel ( this, ID_LOCATION_PANEL );
 
849
        insertChildPanel = new InsertPanel ( this, ID_INSERT_CHILD_PANEL,
 
850
                                             INSERT_PANEL_TYPE_CHILD );
 
851
        insertSiblingPanel = new InsertPanel ( this, ID_INSERT_SIBLING_PANEL,
 
852
                                               INSERT_PANEL_TYPE_SIBLING );
 
853
        insertEntityPanel = new InsertPanel ( this, ID_INSERT_ENTITY_PANEL,
 
854
                                              INSERT_PANEL_TYPE_ENTITY );
 
855
 
 
856
#ifdef __WXMSW__
 
857
        manager.AddPane ( ( wxWindow * ) locationPanel, wxRIGHT, _ ( "Current Element" ) );
 
858
        manager.AddPane ( ( wxWindow * ) insertChildPanel, wxRIGHT, _ ( "Insert Element" ) );
 
859
        manager.AddPane ( ( wxWindow * ) insertSiblingPanel, wxRIGHT, _ ( "Insert Sibling" ) );
 
860
        manager.AddPane ( ( wxWindow * ) insertEntityPanel, wxRIGHT, _ ( "Insert Entity" ) );
 
861
#else
 
862
        manager.AddPane ( ( wxWindow * ) insertEntityPanel, wxRIGHT, _ ( "Insert Entity" ) );
 
863
        manager.AddPane ( ( wxWindow * ) insertSiblingPanel, wxRIGHT, _ ( "Insert Sibling" ) );
 
864
        manager.AddPane ( ( wxWindow * ) insertChildPanel, wxRIGHT, _ ( "Insert Element" ) );
 
865
        manager.AddPane ( ( wxWindow * ) locationPanel, wxRIGHT, _ ( "Current Element" ) );
 
866
#endif
 
867
 
 
868
        manager.GetPane ( locationPanel ).Name ( _T ( "locationPane" ) ).Show (
 
869
            ( restoreLayout ) ? showLocationPane : true ).DestroyOnClose ( false ).PinButton ( true );
 
870
        manager.GetPane ( locationPanel ).dock_proportion = 1;
 
871
 
 
872
        manager.GetPane ( insertChildPanel ).Name ( _T ( "insertChildPane" ) ).Show (
 
873
            ( restoreLayout ) ? showInsertChildPane : true ).DestroyOnClose ( false ).PinButton ( true );
 
874
        manager.GetPane ( insertChildPanel ).dock_proportion = 1;
 
875
 
 
876
        manager.GetPane ( insertSiblingPanel ).Name ( _T ( "insertSiblingPane" ) ).Show (
 
877
            ( restoreLayout ) ? showInsertSiblingPane : true ).DestroyOnClose ( false ).PinButton ( true );
 
878
        manager.GetPane ( insertSiblingPanel ).dock_proportion = 1;
 
879
 
 
880
        manager.GetPane ( insertEntityPanel ).Name ( _T ( "insertEntityPane" ) ).Show (
 
881
            ( restoreLayout ) ? showInsertEntityPane : true ).DestroyOnClose ( false ).PinButton ( true );
 
882
        manager.GetPane ( insertEntityPanel ).dock_proportion = 1;
 
883
 
 
884
        // add (hidden) message pane
 
885
        htmlReport = new MyHtmlPane (
 
886
            this,
 
887
            ID_VALIDATION_PANE,
 
888
            wxDefaultPosition,
 
889
            wxSize ( -1, 48 ) );
 
890
#ifndef __WXMSW__
 
891
        const int sizeArray[] =
 
892
        {
 
893
                8, 9, 10, 11, 12, 13, 14
 
894
        };
 
895
        htmlReport->SetFonts ( wxEmptyString, wxEmptyString, sizeArray );
 
896
#endif
 
897
        htmlReport->SetBorders ( 0 );
 
898
        manager.AddPane ( htmlReport, wxAuiPaneInfo().Movable().Bottom()
 
899
                          .Hide().Name ( _T ( "messagePane" ) )
 
900
                          .DestroyOnClose ( false ).Layer ( 1 ) );
 
901
        manager.GetPane ( htmlReport ).dock_proportion = 1;
 
902
 
 
903
#ifdef NEWFINDREPLACE
 
904
        findReplacePanel = new FindReplacePanel (
 
905
            this,
 
906
            ID_FIND_REPLACE_PANEL,
 
907
            &findData,
 
908
            true,
 
909
            findRegex );
 
910
 
 
911
        manager.AddPane (
 
912
            ( wxWindow * ) findReplacePanel,
 
913
            wxAuiPaneInfo().Bottom().Hide().Caption ( wxEmptyString ).
 
914
            DestroyOnClose ( false ).Layer ( 2 ) );
 
915
#endif
 
916
 
 
917
        commandPanel = new CommandPanel (
 
918
            this,
 
919
            wxID_ANY,
 
920
            commandString, // tbd
 
921
            commandSync, // tbd
 
922
            commandOutput // tbd
 
923
        );
 
924
        manager.AddPane (
 
925
            ( wxWindow * ) commandPanel,
 
926
            wxAuiPaneInfo().Bottom().Hide().Caption ( _T ( "Command" ) ).DestroyOnClose ( false ).Layer ( 3 ) );
 
927
 
 
928
        if ( !wxFileName::DirExists ( applicationDir ) )
 
929
#ifdef __WXMSW__
 
930
                GetStatusBar()->SetStatusText ( _ ( "Cannot open application directory: see Tools, Options..., General" ) );
 
931
#else
 
932
                GetStatusBar()->SetStatusText ( _ ( "Cannot open application directory: see Edit, Preferences..., General" ) );
 
933
#endif
 
934
 
 
935
        // handle command line and, on Windows, MS Word integration
 
936
        handleCommandLineFlag = ( wxTheApp->argc > 1 ) ? true : false;
 
937
 
 
938
        if ( rememberOpenTabs && !openTabsOnClose.empty() )
 
939
                openRememberedTabs();
 
940
        else
 
941
        {
 
942
                if ( !handleCommandLineFlag )
 
943
                        newDocument ( wxEmptyString );
 
944
        }
 
945
 
 
946
#ifdef __WXMSW__
 
947
        DragAcceptFiles ( true ); // currently Windows only
 
948
#endif
 
949
 
 
950
        XmlDoc *doc = getActiveDocument();
 
951
        insertEntityPanel->update ( doc ); // NULL is ok
 
952
 
 
953
        manager.Update();
 
954
 
 
955
        /*
 
956
          defaultLayout = manager.SavePerspective();
 
957
 
 
958
          // restore layout if req'd
 
959
          if (restoreLayout && !layout.empty())
 
960
          {
 
961
            if (!manager.LoadPerspective(layout, true))
 
962
              manager.LoadPerspective(defaultLayout, true);
 
963
          }
 
964
        */
 
965
}
 
966
 
 
967
MyFrame::~MyFrame()
 
968
{
 
969
        std::vector<wxString>::iterator it;
 
970
        for ( it = tempFileVector.begin(); it != tempFileVector.end(); it++ )
 
971
                wxRemoveFile ( *it );
 
972
 
 
973
        layout = manager.SavePerspective();
 
974
        if ( !config )
 
975
                return;
 
976
        history.Save ( *config );
 
977
        config->Write ( _T ( "insertCloseTag" ), properties.insertCloseTag );
 
978
        config->Write ( _T ( "completion" ), properties.completion );
 
979
        config->Write ( _T ( "number" ), properties.number );
 
980
        config->Write ( _T ( "fold" ), properties.fold );
 
981
        config->Write ( _T ( "currentLine" ), properties.currentLine );
 
982
        config->Write ( _T ( "whitespaceVisible" ), properties.whitespaceVisible );
 
983
        config->Write ( _T ( "wrap" ), properties.wrap );
 
984
        config->Write ( _T ( "indentLines" ), properties.indentLines );
 
985
        config->Write ( _T ( "zoom" ), properties.zoom );
 
986
        config->Write ( _T ( "colorScheme" ), properties.colorScheme );
 
987
        config->Write ( _T ( "protectHiddenElements" ), properties.protectHiddenElements );
 
988
        config->Write ( _T ( "toggleLineBackground" ), properties.toggleLineBackground );
 
989
        config->Write ( _T ( "deleteWholeTag" ), properties.deleteWholeTag );
 
990
        config->Write ( _T ( "validateAsYouType" ), properties.validateAsYouType );
 
991
        config->Write ( _T ( "font" ), properties.font );
 
992
        config->Write ( _T ( "highlightSyntax" ), properties.highlightSyntax );
 
993
        config->Write ( _T ( "applicationDir" ), applicationDir );
 
994
        config->Write ( _T ( "ruleSetPreset" ), ruleSetPreset );
 
995
        config->Write ( _T ( "dictionaryPreset" ), dictionaryPreset );
 
996
        config->Write ( _T ( "filterPreset" ), filterPreset );
 
997
        config->Write ( _T ( "xpathExpression" ), xpathExpression );
 
998
        config->Write ( _T ( "findReplaceFind" ), findData.GetFindString() );
 
999
        config->Write ( _T ( "findReplaceReplace" ), findData.GetReplaceString() );
 
1000
        config->Write ( _T ( "globalReplaceAllDocuments" ), globalReplaceAllDocuments );
 
1001
        config->Write ( _T ( "showFullPathOnFrame" ), showFullPathOnFrame );
 
1002
        config->Write ( _T ( "toolbarVisible" ), toolbarVisible );
 
1003
        config->Write ( _T ( "protectTags" ), protectTags );
 
1004
        config->Write ( _T ( "visibilityState" ), visibilityState );
 
1005
        config->Write ( _T ( "browserCommand" ), browserCommand );
 
1006
        config->Write ( _T ( "showLocationPane" ), manager.GetPane ( locationPanel ).IsShown() );
 
1007
        config->Write ( _T ( "showInsertChildPane" ), manager.GetPane ( insertChildPanel ).IsShown() );
 
1008
        config->Write ( _T ( "showInsertSiblingPane" ), manager.GetPane ( insertSiblingPanel ).IsShown() );
 
1009
        config->Write ( _T ( "showInsertEntityPane" ), manager.GetPane ( insertEntityPanel ).IsShown() );
 
1010
        config->Write ( _T ( "expandInternalEntities" ), expandInternalEntities );
 
1011
        config->Write ( _T ( "findRegex" ), findReplacePanel->getRegex() );
 
1012
        config->Write ( _T ( "findMatchCase" ), ( findData.GetFlags() ) & wxFR_MATCHCASE );
 
1013
        config->Write ( _T ( "commandSync" ), commandPanel->getSync() );
 
1014
        config->Write ( _T ( "commandOutput" ), commandPanel->getOutput() );
 
1015
        config->Write ( _T ( "commandString" ), commandPanel->getCommand() );
 
1016
        config->Write ( _T ( "restoreLayout" ), restoreLayout );
 
1017
        config->Write ( _T ( "lastXslStylesheet" ), lastXslStylesheet );
 
1018
        config->Write ( _T ( "lastRelaxNGSchema" ), lastRelaxNGSchema );
 
1019
        config->Write ( _T ( "exportStylesheet" ), exportStylesheet );
 
1020
        config->Write ( _T ( "exportFolder" ), exportFolder );
 
1021
        config->Write ( _T ( "exportQuiet" ), exportQuiet );
 
1022
        config->Write ( _T ( "exportMp3Album" ), exportMp3Album );
 
1023
 
 
1024
        GetPosition ( &framePosX, &framePosY );
 
1025
        config->Write ( _T ( "framePosX" ), framePosX );
 
1026
        config->Write ( _T ( "framePosY" ), framePosY );
 
1027
        GetSize ( &frameWidth, &frameHeight );
 
1028
        config->Write ( _T ( "frameWidth" ), frameWidth );
 
1029
        config->Write ( _T ( "frameHeight" ), frameHeight );
 
1030
 
 
1031
        config->Write ( _T ( "rememberOpenTabs" ), rememberOpenTabs );
 
1032
        config->Write ( _T ( "openTabsOnClose" ), openTabsOnClose );
 
1033
        config->Write ( _T ( "libxmlNetAccess" ), libxmlNetAccess );
 
1034
 
 
1035
        config->Write ( _T ( "singleInstanceCheck" ), singleInstanceCheck );
 
1036
        config->Write ( _T ( "lang" ), lang );
 
1037
        config->Write ( _T ( "notebookStyle" ), notebookStyle );
 
1038
        config->Write ( _T ( "saveBom" ), saveBom );
 
1039
        config->Write ( _T ( "unlimitedUndo" ), unlimitedUndo );
 
1040
        manager.UnInit();
 
1041
        wxTheClipboard->Flush();
 
1042
}
 
1043
 
 
1044
wxString MyFrame::getLinuxBrowser()
 
1045
{
 
1046
        wxString s;
 
1047
        const int stringArrayLen = 10;
 
1048
        wxString stringArray[stringArrayLen];
 
1049
        stringArray[0] = _T ( "/usr/bin/x-www-browser" );
 
1050
        stringArray[1] = _T ( "/usr/bin/firefox" );
 
1051
        stringArray[2] = _T ( "/usr/bin/mozilla" );
 
1052
        stringArray[3] = _T ( "/usr/bin/opera" );
 
1053
        stringArray[4] = _T ( "/usr/bin/dillo" );
 
1054
        stringArray[5] = _T ( "/opt/gnome/bin/epiphany" );
 
1055
        stringArray[6] = _T ( "/opt/gnome/bin/galeon" );
 
1056
        stringArray[7] = _T ( "/opt/kde/bin/konqueror" );
 
1057
        stringArray[8] = _T ( "/opt/mozilla/bin/firefox" );
 
1058
        stringArray[9] = wxEmptyString; // empty option is safe
 
1059
 
 
1060
        for ( int i = 0; i < stringArrayLen; i++ )
 
1061
        {
 
1062
                s = stringArray[i];
 
1063
                if ( wxFileName::FileExists ( s ) )
 
1064
                        break;
 
1065
        }
 
1066
        return s;
 
1067
}
 
1068
 
 
1069
void MyFrame::showTopBars ( bool b )
 
1070
{
 
1071
        if ( !menuBar )
 
1072
        {
 
1073
                SetToolBar ( NULL );
 
1074
                menuBar = getMenuBar();
 
1075
                SetMenuBar ( menuBar );
 
1076
        }
 
1077
        if ( b )
 
1078
        {
 
1079
                if ( !toolBar )
 
1080
                        toolBar = getToolBar();
 
1081
                SetToolBar ( toolBar );
 
1082
        }
 
1083
        else
 
1084
        {
 
1085
                SetToolBar ( NULL );
 
1086
                delete toolBar;
 
1087
                toolBar = NULL;
 
1088
        }
 
1089
}
 
1090
 
 
1091
void MyFrame::handleCommandLine()
 
1092
{
 
1093
        bool wordFlag, styleFlag;
 
1094
        wordFlag = styleFlag = false;
 
1095
        wxChar c;
 
1096
 
 
1097
        int m_argc = wxTheApp->argc;
 
1098
        wxChar **m_argv = wxTheApp->argv;
 
1099
 
 
1100
        while ( ( --m_argc > 0 && ( *++m_argv ) [0] == L'-' ) != 0 )
 
1101
        {
 
1102
                wxString wideVersion ( ABOUT_VERSION );
 
1103
                std::string version = ( const char * ) wideVersion.mb_str ( wxConvUTF8 );
 
1104
                while ( ( c = *++m_argv[0] ) != 0 )
 
1105
                {
 
1106
                        switch ( c )
 
1107
                        {
 
1108
                                case L'w':
 
1109
                                        wordFlag = true;
 
1110
                                        break;
 
1111
                                case L's':
 
1112
                                        styleFlag = true;
 
1113
                                        break;
 
1114
                                case L'-':
 
1115
                                        if ( *++m_argv[0] == L'v' )
 
1116
                                        {
 
1117
                                                std::cout << version.c_str() << std::endl;
 
1118
                                        }
 
1119
                                        else
 
1120
                                        {
 
1121
                                                std::cout << "Usage: xmlcopyeditor [--version --help -ws] [<file>] [<file2>]" << std::endl << "Options -w (import Microsoft Word document) and -s (open Spelling and style check) are provided for integration with Microsoft Office and only available on Windows" << std::endl;
 
1122
                                        }
 
1123
                                        exit ( 0 );
 
1124
                                default:
 
1125
                                        messagePane ( _ ( "Unknown command line switch (expecting 'w', 's', --version or --help)" ),
 
1126
                                                      CONST_STOP );
 
1127
                                        return;
 
1128
                        }
 
1129
                }
 
1130
        }
 
1131
 
 
1132
        if ( ! ( *m_argv ) )
 
1133
        {
 
1134
                messagePane ( _ ( "Command line processing incomplete: no file specified" ),
 
1135
                              CONST_STOP );
 
1136
                return;
 
1137
        }
 
1138
 
 
1139
        wxString fileName;
 
1140
 
 
1141
        // no flags specified or not Windows
 
1142
#ifdef __WXMSW__
 
1143
        if ( !styleFlag && !wordFlag )
 
1144
#endif
 
1145
        {
 
1146
                for ( ; *m_argv; ++m_argv )
 
1147
                {
 
1148
                        fileName = wxString ( *m_argv, wxConvLocal, wcslen ( *m_argv ) );
 
1149
                        fileName = PathResolver::run ( fileName );
 
1150
                        if ( isOpen ( fileName ) )
 
1151
                                continue;
 
1152
                        else if ( !openFile ( fileName ) )
 
1153
                                break;
 
1154
                }
 
1155
                return;
 
1156
        }
 
1157
 
 
1158
        // options only available on Windows
 
1159
        fileName = wxString ( *m_argv, wxConvLocal, wcslen ( *m_argv ) );
 
1160
 
 
1161
        // fetch as many parameters as possible
 
1162
        for ( ;; )
 
1163
        {
 
1164
                ++m_argv;
 
1165
                if ( ! ( *m_argv ) )
 
1166
                        break;
 
1167
                ruleSetPreset = wxString ( *m_argv, wxConvLocal, wcslen ( *m_argv ) );
 
1168
 
 
1169
                ++m_argv;
 
1170
                if ( ! ( *m_argv ) )
 
1171
                        break;
 
1172
                filterPreset = wxString ( *m_argv, wxConvLocal, wcslen ( *m_argv ) );
 
1173
 
 
1174
                ++m_argv;
 
1175
                if ( ! ( *m_argv ) )
 
1176
                        break;
 
1177
                applicationDir = wxString ( *m_argv, wxConvLocal, wcslen ( *m_argv ) );
 
1178
                updatePaths();
 
1179
 
 
1180
                break;
 
1181
        }
 
1182
        if ( wordFlag )
 
1183
                importMSWord ( fileName );
 
1184
        else
 
1185
                openFile ( fileName );
 
1186
 
 
1187
        if ( styleFlag && !ruleSetPreset.empty() && !filterPreset.empty() )
 
1188
        {
 
1189
                wxCommandEvent e;
 
1190
                OnSpelling ( e );
 
1191
        }
 
1192
}
 
1193
 
 
1194
bool MyFrame::isOpen ( const wxString& fileName )
 
1195
{
 
1196
        return ( openFileSet.find ( fileName ) != openFileSet.end() );
 
1197
}
 
1198
 
 
1199
bool MyFrame::activateTab ( const wxString& fileName )
 
1200
{
 
1201
        int pageCount = mainBook->GetPageCount();
 
1202
        XmlDoc *currentDoc;
 
1203
        for ( int i = 0; i < pageCount; ++i )
 
1204
        {
 
1205
                currentDoc = ( XmlDoc * ) mainBook->GetPage ( i );
 
1206
                if ( !currentDoc )
 
1207
                        break;
 
1208
                if ( currentDoc->getFullFileName() == fileName )
 
1209
                {
 
1210
                        mainBook->SetSelection ( i );
 
1211
                        return true;
 
1212
                }
 
1213
        }
 
1214
        return false;
 
1215
}
 
1216
 
 
1217
void MyFrame::OnAbout ( wxCommandEvent& WXUNUSED ( event ) )
 
1218
{
 
1219
        wxString description;
 
1220
        description = ABOUT_DESCRIPTION;
 
1221
        description.Append ( _T("\n\nFramework version: ") );
 
1222
        description.Append ( wxVERSION_STRING );
 
1223
        description.Append ( _T("\n") );
 
1224
 
 
1225
        wxAboutDialogInfo info;
 
1226
        info.SetName ( _ ( "XML Copy Editor" ) );
 
1227
        info.SetWebSite ( _T ( "http://xml-copy-editor.sourceforge.net" ) );
 
1228
        info.SetVersion ( ABOUT_VERSION );
 
1229
        info.SetCopyright ( ABOUT_COPYRIGHT );
 
1230
        info.AddDeveloper ( _ ( "Gerald Schmidt (development) <gnschmidt at users dot sourceforge dot net>" ) );
 
1231
        info.AddDeveloper ( _ ( "Matt Smigielski (testing) <alectrus at users dot sourceforge dot net>" ) );
 
1232
        info.AddDeveloper ( _ ( "Justin Dearing (development) <j-pimp at users dot sourceforge dot net>" ) );
 
1233
        info.AddDeveloper ( _ ( "Kev James (development) <kmjames at users dot sourceforge dot net>" ) );
 
1234
        info.AddDeveloper ( _ ( "Anh Trinh (development) <ant271 at users dot sourceforge dot net>" ) );
 
1235
        info.AddDeveloper ( _ ( "Esther L\x00F6liger (development) <eloeliger at users dot sourceforge dot net>" ) );
 
1236
        info.AddTranslator ( _ ( "Viliam Búr (Slovak) <viliam at bur dot sk>" ) );
 
1237
        info.AddTranslator ( _ ( "David Håsäther (Swedish) <hasather at gmail dot com>" ) );
 
1238
        info.AddTranslator ( _ ( "François Badier (French) <frabad at gmail dot com>" ) );
 
1239
        info.AddTranslator ( _ ( "Thomas Wenzel (German) <thowen at users dot sourceforge.net>" ) );
 
1240
        info.AddTranslator ( _ ( "SHiNE CsyFeK (Chinese Simplified) <csyfek at gmail dot com>" ) );
 
1241
        info.AddTranslator ( _ ( "HSU PICHAN, YANG SHUFUN, CHENG PAULIAN, CHUANG KUO-PING, Marcus Bingenheimer (Chinese Traditional)" ) );
 
1242
        info.AddTranslator ( _ ( "Serhij Dubyk (Ukrainian) <dubyk at library dot lviv dot ua>" ) );
 
1243
        info.AddTranslator ( _ ( "Antonio Angelo (Italian) <aangelo at users dot sourceforge dot net>" ) );
 
1244
        info.AddTranslator ( _ ( "Siarhei Kuchuk (Russian) <Cuchuk dot Sergey at gmail dot com>" ) );
 
1245
        info.AddTranslator ( _ ( "Marcos Pérez González (Spanish) <marcos_pg at yahoo dot com>" ) );
 
1246
        info.AddTranslator ( _ ( "Rob Elemans (Dutch) <relemans at gmail dot com>" ) );
 
1247
        info.AddTranslator ( _ ( "Robert Falc\xf3 Miramontes <rfalco at acett dot org>" ) );
 
1248
    info.SetLicense ( ABOUT_LICENSE );
 
1249
        info.SetDescription ( description );
 
1250
        wxAboutBox ( info );
 
1251
        XmlDoc *doc;
 
1252
        if ( ( doc = getActiveDocument() ) == NULL )
 
1253
                return;
 
1254
        doc->SetFocus();
 
1255
}
 
1256
 
 
1257
void MyFrame::OnCheckWellformedness ( wxCommandEvent& event )
 
1258
{
 
1259
    statusProgress ( wxEmptyString );
 
1260
        XmlDoc *doc;
 
1261
        if ( ( doc = getActiveDocument() ) == NULL )
 
1262
                return;
 
1263
 
 
1264
        std::string utf8Buffer;
 
1265
        getRawText ( doc, utf8Buffer );
 
1266
        if ( utf8Buffer.empty() )
 
1267
                return;
 
1268
 
 
1269
        // handle unusual encodings
 
1270
        if ( !XmlEncodingHandler::setUtf8 ( utf8Buffer ) )
 
1271
        {
 
1272
                encodingMessage();
 
1273
                return;
 
1274
        }
 
1275
 
 
1276
        doc->clearErrorIndicators();
 
1277
        statusProgress ( _ ( "Parse in progress..." ) );
 
1278
 
 
1279
        // check for well-formedness
 
1280
        auto_ptr<WrapExpat> we ( new WrapExpat() );
 
1281
        if ( !we->parse ( utf8Buffer.c_str() ) )
 
1282
        {
 
1283
                std::string error = we->getLastError();
 
1284
                wxString werror = wxString ( error.c_str(), wxConvUTF8, error.size() );
 
1285
                statusProgress ( wxEmptyString );
 
1286
                messagePane ( werror, CONST_WARNING );
 
1287
                std::pair<int, int> posPair = we->getErrorPosition();
 
1288
                -- ( posPair.first );
 
1289
                int cursorPos =
 
1290
                    doc->PositionFromLine ( posPair.first );
 
1291
                doc->SetSelection ( cursorPos, cursorPos );
 
1292
 
 
1293
                doc->setErrorIndicator ( posPair.first, posPair.second );
 
1294
                return;
 
1295
        }
 
1296
 
 
1297
        statusProgress ( wxEmptyString );
 
1298
        documentOk ( _ ( "well-formed" ) );
 
1299
}
 
1300
 
 
1301
void MyFrame::OnPageClosing ( wxAuiNotebookEvent& event ) //wxNotebookEvent& event)//wxFlatNotebookEvent& event)
 
1302
{
 
1303
        deletePageVetoed = false;
 
1304
 
 
1305
        if ( insertChildPanel && insertSiblingPanel && locationPanel )
 
1306
        {
 
1307
                insertChildPanel->update ( NULL, wxEmptyString );
 
1308
                insertSiblingPanel->update ( NULL, wxEmptyString );
 
1309
                locationPanel->update();
 
1310
                manager.Update();
 
1311
        }
 
1312
 
 
1313
        XmlDoc *doc;
 
1314
        doc = ( XmlDoc * ) mainBook->GetPage ( event.GetSelection() );
 
1315
        if ( !doc )
 
1316
                return;
 
1317
 
 
1318
        statusProgress ( wxEmptyString );
 
1319
        closePane();
 
1320
 
 
1321
        if ( doc->GetModify() ) //CanUndo())
 
1322
        {
 
1323
                int selection;
 
1324
                wxString fileName;
 
1325
                if ( ( selection = mainBook->GetSelection() ) != -1 )
 
1326
                        fileName = doc->getShortFileName();
 
1327
 
 
1328
                int answer = wxMessageBox (
 
1329
                                 _ ( "Do you want to save the changes to " ) + fileName + _T ( "?" ),
 
1330
                                 _ ( "XML Copy Editor" ),
 
1331
                                 wxYES_NO | wxCANCEL | wxICON_QUESTION,
 
1332
                                 this );
 
1333
 
 
1334
                if ( answer == wxCANCEL )
 
1335
                {
 
1336
                        event.Veto();
 
1337
                        deletePageVetoed = true;
 
1338
                        return;
 
1339
                }
 
1340
                else if ( answer == wxYES )
 
1341
                {
 
1342
                        wxCommandEvent event;
 
1343
                        OnSave ( event );
 
1344
                }
 
1345
        }
 
1346
        statusProgress ( wxEmptyString );
 
1347
 
 
1348
        openFileSet.erase ( doc->getFullFileName() );
 
1349
        event.Skip();
 
1350
}
 
1351
 
 
1352
void MyFrame::OnClose ( wxCommandEvent& WXUNUSED ( event ) )
 
1353
{
 
1354
        closeActiveDocument();
 
1355
}
 
1356
 
 
1357
void MyFrame::OnCloseAll ( wxCommandEvent& WXUNUSED ( event ) )
 
1358
{
 
1359
        if ( !mainBook )
 
1360
                return;
 
1361
        openTabsOnClose = wxEmptyString;
 
1362
 
 
1363
        // retain tab order
 
1364
        if ( rememberOpenTabs && !openFileSet.empty() )
 
1365
        {
 
1366
                XmlDoc *doc;
 
1367
                wxString fullPath;
 
1368
                size_t maxTabs = mainBook->GetPageCount();
 
1369
                for ( size_t i = 0; i < maxTabs; ++i )
 
1370
                {
 
1371
                        doc = ( XmlDoc * ) mainBook->GetPage ( i );
 
1372
                        if ( doc )
 
1373
                        {
 
1374
                                fullPath = doc->getFullFileName();
 
1375
                                if ( !fullPath.empty() )
 
1376
                                {
 
1377
                                        openTabsOnClose.Append ( fullPath );
 
1378
                                        openTabsOnClose.Append ( _T ( "|" ) );
 
1379
                                }
 
1380
                        }
 
1381
                }
 
1382
        }
 
1383
 
 
1384
        while ( closeActiveDocument() )
 
1385
                ;
 
1386
}
 
1387
 
 
1388
void MyFrame::OnClosePane ( wxCommandEvent& WXUNUSED ( event ) )
 
1389
{
 
1390
        closePane();
 
1391
        //closeFindReplacePane();
 
1392
        //closeCommandPane();
 
1393
 
 
1394
        XmlDoc *doc = getActiveDocument();
 
1395
        if ( doc )
 
1396
                doc->SetFocus();
 
1397
}
 
1398
 
 
1399
void MyFrame::closePane()
 
1400
{
 
1401
        if ( !htmlReport )
 
1402
                return;
 
1403
        manager.GetPane ( htmlReport ).Hide();
 
1404
        manager.Update();
 
1405
 
 
1406
        XmlDoc *doc;
 
1407
        if ( ( doc = getActiveDocument() ) == NULL )
 
1408
                return;
 
1409
        doc->SetFocus();
 
1410
}
 
1411
 
 
1412
void MyFrame::closeFindReplacePane()
 
1413
{
 
1414
        if ( manager.GetPane ( findReplacePanel ).IsShown() )
 
1415
                manager.GetPane ( findReplacePanel ).Hide();
 
1416
        manager.Update();
 
1417
}
 
1418
 
 
1419
void MyFrame::closeCommandPane()
 
1420
{
 
1421
        if ( manager.GetPane ( commandPanel ).IsShown() )
 
1422
                manager.GetPane ( commandPanel ).Hide();
 
1423
        manager.Update();
 
1424
}
 
1425
 
 
1426
bool MyFrame::panelHasFocus()
 
1427
{
 
1428
        XmlDoc *doc = getActiveDocument();
 
1429
        return ( !doc || ( FindFocus() != ( wxWindow * ) doc ) );
 
1430
}
 
1431
 
 
1432
void MyFrame::OnCut ( wxCommandEvent& event )
 
1433
{
 
1434
        if ( panelHasFocus() )
 
1435
        {
 
1436
                event.Skip();
 
1437
                return;
 
1438
        }
 
1439
 
 
1440
        XmlDoc *doc;
 
1441
        if ( ( doc = getActiveDocument() ) == NULL )
 
1442
                return;
 
1443
 
 
1444
        if ( protectTags )
 
1445
                doc->adjustSelection();
 
1446
 
 
1447
        doc->Cut();
 
1448
        doc->setValidationRequired ( true );
 
1449
}
 
1450
 
 
1451
void MyFrame::OnCopy ( wxCommandEvent& event )
 
1452
{
 
1453
        if ( panelHasFocus() )
 
1454
        {
 
1455
                event.Skip();
 
1456
                return;
 
1457
        }
 
1458
 
 
1459
        XmlDoc *doc;
 
1460
        if ( ( doc = getActiveDocument() ) == NULL )
 
1461
                return;
 
1462
        doc->Copy();
 
1463
}
 
1464
 
 
1465
void MyFrame::OnPaste ( wxCommandEvent& event )
 
1466
{
 
1467
        if ( panelHasFocus() )
 
1468
        {
 
1469
                event.Skip();
 
1470
                return;
 
1471
        }
 
1472
        XmlDoc *doc;
 
1473
        if ( ( doc = getActiveDocument() ) == NULL )
 
1474
                return;
 
1475
 
 
1476
        // this has to be handled here to override Scintilla's default Ctrl+V support
 
1477
        if ( protectTags )
 
1478
        {
 
1479
                if ( !wxTheClipboard->Open() || !wxTheClipboard->IsSupported ( wxDF_TEXT ) )
 
1480
                        return;
 
1481
                wxTextDataObject data;
 
1482
                wxTheClipboard->GetData ( data );
 
1483
                wxString buffer = data.GetText();
 
1484
                wxTheClipboard->Close();
 
1485
                xmliseWideTextNode ( buffer );
 
1486
                doc->adjustCursor();
 
1487
                doc->AddText ( buffer );
 
1488
        }
 
1489
        else
 
1490
                doc->Paste();
 
1491
}
 
1492
 
 
1493
void MyFrame::OnIdle ( wxIdleEvent& event )
 
1494
{
 
1495
        wxStatusBar *status = GetStatusBar();
 
1496
        if ( !status )
 
1497
                return;
 
1498
 
 
1499
    /*
 
1500
    // IPC handling: take one file from fileQueue at a time
 
1501
    if ( !fileQueue.empty() )
 
1502
    {
 
1503
      openFile ( * ( fileQueue.begin() ) );
 
1504
      fileQueue.erase( fileQueue.begin() );  
 
1505
    }
 
1506
    */
 
1507
 
 
1508
        // update attributes hidden field even if no document loaded
 
1509
        wxString currentHiddenStatus = status->GetStatusText ( STATUS_HIDDEN );
 
1510
        if ( visibilityState == HIDE_ATTRIBUTES )
 
1511
        {
 
1512
                if ( currentHiddenStatus != _ ( "Attributes hidden" ) )
 
1513
                        status->SetStatusText (
 
1514
                            _ ( "Attributes hidden" ),
 
1515
                            STATUS_HIDDEN );
 
1516
        }
 
1517
        else if ( visibilityState == HIDE_TAGS )
 
1518
        {
 
1519
                if ( currentHiddenStatus != _ ( "Tags hidden" ) )
 
1520
                        status->SetStatusText (
 
1521
                            _ ( "Tags hidden" ),
 
1522
                            STATUS_HIDDEN );
 
1523
        }
 
1524
        else
 
1525
        {
 
1526
                if ( !currentHiddenStatus.empty() )
 
1527
                        status->SetStatusText ( wxEmptyString, STATUS_HIDDEN );
 
1528
        }
 
1529
 
 
1530
        // update protected field even if no document loaded
 
1531
        wxString currentProtectedStatus = status->GetStatusText ( STATUS_PROTECTED );
 
1532
        if ( protectTags )
 
1533
        {
 
1534
                if ( currentProtectedStatus != _ ( "Tags locked" ) )
 
1535
                        status->SetStatusText (
 
1536
                            _ ( "Tags locked" ),
 
1537
                            STATUS_PROTECTED );
 
1538
        }
 
1539
        else
 
1540
        {
 
1541
                if ( !currentProtectedStatus.empty() )
 
1542
                        status->SetStatusText ( wxEmptyString, STATUS_PROTECTED );
 
1543
        }
 
1544
 
 
1545
        // check if document loaded
 
1546
        wxString frameTitle = GetTitle();
 
1547
 
 
1548
        XmlDoc *doc;
 
1549
        if ( ( doc = getActiveDocument() ) == NULL )
 
1550
        {
 
1551
                if ( lastDoc != NULL )
 
1552
                {
 
1553
                        lastDoc = NULL;
 
1554
                        status->SetStatusText ( wxEmptyString, STATUS_MODIFIED );
 
1555
                        status->SetStatusText ( wxEmptyString, STATUS_POSITION );
 
1556
                        locationPanel->update ( NULL, wxEmptyString );
 
1557
                        insertChildPanel->update ( NULL, wxEmptyString );
 
1558
                        insertSiblingPanel->update ( NULL, wxEmptyString );
 
1559
                        insertEntityPanel->update ( NULL, wxEmptyString );
 
1560
                        wxString minimal = _ ( "XML Copy Editor" );
 
1561
                        if ( frameTitle != minimal )
 
1562
                                SetTitle ( minimal );
 
1563
 
 
1564
                        closeFindReplacePane();
 
1565
 
 
1566
                        event.Skip();
 
1567
                        manager.Update();
 
1568
                }
 
1569
                return;
 
1570
        }
 
1571
 
 
1572
        if ( restoreFocusToNotebook )
 
1573
        {
 
1574
                doc->SetFocus();
 
1575
                restoreFocusToNotebook = false;
 
1576
        }
 
1577
 
 
1578
        wxString docTitle;
 
1579
        if ( doc->getFullFileName().empty() || !showFullPathOnFrame )
 
1580
                docTitle = doc->getShortFileName();
 
1581
        else
 
1582
                docTitle = doc->getFullFileName();
 
1583
 
 
1584
        docTitle += _T ( " - " );
 
1585
        docTitle += _ ( "XML Copy Editor" );
 
1586
 
 
1587
        if ( frameTitle != docTitle )
 
1588
                SetTitle ( docTitle );
 
1589
 
 
1590
    // update modified field
 
1591
        if ( !mainBook )
 
1592
                return;
 
1593
        int index = mainBook->GetSelection();
 
1594
 
 
1595
        wxString currentModifiedStatus = status->GetStatusText ( STATUS_MODIFIED );
 
1596
        wxString currentTabLabel = mainBook->GetPageText ( index );
 
1597
        if ( doc->GetModify() )
 
1598
        {
 
1599
                if ( currentModifiedStatus != _ ( "Modified" ) )
 
1600
                {
 
1601
                        status->SetStatusText ( _ ( "Modified" ), STATUS_MODIFIED );
 
1602
 
 
1603
                        if ( ! ( currentTabLabel.Mid ( 0, 1 ) == _T ( "*" ) ) )
 
1604
                        {
 
1605
                                currentTabLabel.Prepend ( _T ( "*" ) );
 
1606
                                mainBook->SetPageText ( index, currentTabLabel );
 
1607
                        }
 
1608
                }
 
1609
        }
 
1610
        else
 
1611
        {
 
1612
                if ( !currentModifiedStatus.empty() )
 
1613
                {
 
1614
                        status->SetStatusText ( _T ( "" ), STATUS_MODIFIED );
 
1615
 
 
1616
                        if ( currentTabLabel.Mid ( 0, 1 ) == _T ( "*" ) )
 
1617
                        {
 
1618
                                currentTabLabel.Remove ( 0, 1 );
 
1619
                                mainBook->SetPageText ( index, currentTabLabel );
 
1620
                        }
 
1621
                }
 
1622
        }
 
1623
 
 
1624
        // update coordinates field
 
1625
        std::pair<int, int> myControlCoordinates;
 
1626
        int current = doc->GetCurrentPos();
 
1627
        myControlCoordinates.first = doc->LineFromPosition ( current ) + 1;
 
1628
        myControlCoordinates.second = doc->GetColumn ( current ) + 1;
 
1629
 
 
1630
        if ( myControlCoordinates != controlCoordinates )
 
1631
        {
 
1632
                wxString coordinates;
 
1633
                coordinates.Printf (
 
1634
                    _ ( "Ln %i Col %i" ),
 
1635
                    myControlCoordinates.first,
 
1636
                    myControlCoordinates.second );
 
1637
                GetStatusBar()->SetStatusText ( coordinates, STATUS_POSITION );
 
1638
                controlCoordinates = myControlCoordinates;
 
1639
        }
 
1640
 
 
1641
        // update parent element field
 
1642
        wxString parent, grandparent;
 
1643
        if ( current == lastPos && doc == lastDoc )
 
1644
                return;
 
1645
 
 
1646
        lastPos = current;
 
1647
        lastDoc = doc;
 
1648
 
 
1649
 
 
1650
        // don't try to find parent if pane is not shown
 
1651
        if ( !manager.GetPane ( insertChildPanel ).IsShown() && !properties.validateAsYouType )
 
1652
                return;
 
1653
 
 
1654
        int parentCloseAngleBracket = -1;
 
1655
        if ( !doc->canInsertAt ( current ) )
 
1656
                parent = grandparent = wxEmptyString;
 
1657
        else
 
1658
        {
 
1659
                parentCloseAngleBracket = doc->getParentCloseAngleBracket ( current );
 
1660
                parent = doc->getLastElementName ( parentCloseAngleBracket );
 
1661
        }
 
1662
 
 
1663
        if ( !parent.empty() && properties.validateAsYouType && doc->getValidationRequired() )
 
1664
        {
 
1665
                // tbd: limit to parent element
 
1666
                doc->backgroundValidate();
 
1667
        }
 
1668
 
 
1669
 
 
1670
        if ( parent == lastParent )
 
1671
                return;
 
1672
        lastParent = parent;
 
1673
 
 
1674
        bool mustUpdate = false;
 
1675
        if ( locationPanel && insertChildPanel && insertEntityPanel )
 
1676
        {
 
1677
                locationPanel->update ( doc, parent );
 
1678
                insertChildPanel->update ( doc, parent );
 
1679
                insertEntityPanel->update ( doc );
 
1680
                mustUpdate = true;
 
1681
        }
 
1682
 
 
1683
        if ( parent.empty() )
 
1684
        {
 
1685
                if ( insertSiblingPanel )
 
1686
                        insertSiblingPanel->update ( doc, wxEmptyString );
 
1687
                if ( mustUpdate )
 
1688
                        manager.Update();
 
1689
                return;
 
1690
        }
 
1691
 
 
1692
        if ( !manager.GetPane ( insertSiblingPanel ).IsShown() )
 
1693
        {
 
1694
                if ( mustUpdate )
 
1695
                        manager.Update();
 
1696
                return;
 
1697
        }
 
1698
 
 
1699
        // try to fetch grandparent if necessary/possible
 
1700
        if ( !parent.empty() && parentCloseAngleBracket != -1 )
 
1701
        {
 
1702
                int grandParentCloseAngleBracket;
 
1703
                grandParentCloseAngleBracket =
 
1704
                    doc->getParentCloseAngleBracket (
 
1705
                        doc->getTagStartPos ( parentCloseAngleBracket ) );
 
1706
                grandparent = doc->getLastElementName ( grandParentCloseAngleBracket );
 
1707
 
 
1708
                if ( insertSiblingPanel )
 
1709
                        insertSiblingPanel->update ( doc, parent, grandparent );
 
1710
                if ( grandparent != lastGrandparent )
 
1711
                {
 
1712
                        mustUpdate = true;
 
1713
                        lastGrandparent = grandparent;
 
1714
                }
 
1715
 
 
1716
        }
 
1717
        if ( mustUpdate )
 
1718
                manager.Update();
 
1719
}
 
1720
 
 
1721
void MyFrame::OnInsertChild ( wxCommandEvent& event )
 
1722
{
 
1723
        if ( !insertChildPanel )
 
1724
                return;
 
1725
 
 
1726
        wxAuiPaneInfo info = manager.GetPane ( insertChildPanel );
 
1727
        if ( !info.IsOk() )
 
1728
        {
 
1729
                return;
 
1730
        }
 
1731
        if ( !info.IsShown() )
 
1732
        {
 
1733
                manager.GetPane ( insertChildPanel ).Show ( true );
 
1734
                manager.Update();
 
1735
        }
 
1736
        insertChildPanel->setEditFocus();
 
1737
}
 
1738
 
 
1739
void MyFrame::OnInsertSibling ( wxCommandEvent& event )
 
1740
{
 
1741
        if ( !insertSiblingPanel )
 
1742
                return;
 
1743
 
 
1744
        wxAuiPaneInfo info = manager.GetPane ( insertSiblingPanel );
 
1745
        if ( !info.IsOk() )
 
1746
        {
 
1747
                return;
 
1748
        }
 
1749
 
 
1750
        if ( !info.IsShown() )
 
1751
        {
 
1752
                manager.GetPane ( insertSiblingPanel ).Show ( true );
 
1753
                manager.Update();
 
1754
        }
 
1755
        insertSiblingPanel->setEditFocus();
 
1756
}
 
1757
 
 
1758
void MyFrame::OnInsertEntity ( wxCommandEvent& event )
 
1759
{
 
1760
        if ( !insertEntityPanel )
 
1761
                return;
 
1762
 
 
1763
        wxAuiPaneInfo info = manager.GetPane ( insertEntityPanel );
 
1764
        if ( !info.IsOk() )
 
1765
        {
 
1766
                return;
 
1767
        }
 
1768
 
 
1769
        if ( !info.IsShown() )
 
1770
        {
 
1771
                manager.GetPane ( insertEntityPanel ).Show ( true );
 
1772
                manager.Update();
 
1773
        }
 
1774
        insertEntityPanel->setEditFocus();
 
1775
}
 
1776
 
 
1777
void MyFrame::OnInsertSymbol ( wxCommandEvent& event )
 
1778
{
 
1779
        XmlDoc *doc;
 
1780
        if ( ( doc = getActiveDocument() ) == NULL )
 
1781
                return;
 
1782
        wxSymbolPickerDialog dlg ( _T ( "*" ), wxEmptyString, properties.font, this );
 
1783
 
 
1784
        if ( dlg.ShowModal() == wxID_OK )
 
1785
        {
 
1786
                if ( dlg.HasSelection() )
 
1787
                {
 
1788
                        doc->AddText ( dlg.GetSymbol() );
 
1789
                }
 
1790
        }
 
1791
}
 
1792
 
 
1793
void MyFrame::OnInsertTwin ( wxCommandEvent& event )
 
1794
{
 
1795
        XmlDoc *doc;
 
1796
        if ( ( doc = getActiveDocument() ) == NULL )
 
1797
                return;
 
1798
 
 
1799
        wxString parent = doc->getParent();
 
1800
        if ( !doc->insertSibling ( parent, parent ) )
 
1801
        {
 
1802
                wxString msg;
 
1803
                msg.Printf ( _T ( "Cannot insert twin '%s'" ), parent.c_str() );
 
1804
                messagePane ( msg, CONST_STOP );
 
1805
        }
 
1806
        doc->setValidationRequired ( true );
 
1807
        doc->SetFocus();
 
1808
}
 
1809
 
 
1810
void MyFrame::OnPasteNewDocument ( wxCommandEvent& event )
 
1811
{
 
1812
        if ( !wxTheClipboard->Open() )
 
1813
        {
 
1814
                messagePane ( _ ( "Cannot open clipboard" ), CONST_STOP );
 
1815
                return;
 
1816
        }
 
1817
        if ( !wxTheClipboard->IsSupported ( wxDF_TEXT ) )
 
1818
        {
 
1819
                messagePane ( _ ( "Cannot paste as new document: no text on clipboard" ), CONST_STOP );
 
1820
                return;
 
1821
        }
 
1822
        wxTextDataObject data;
 
1823
        wxTheClipboard->GetData ( data );
 
1824
 
 
1825
        wxString buffer = data.GetText();
 
1826
        xmliseWideTextNode ( buffer );
 
1827
 
 
1828
        buffer.Prepend ( _T ( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>" ) );
 
1829
        buffer.Append ( _T ( "</root>\n" ) );
 
1830
 
 
1831
        newDocument ( buffer );
 
1832
        wxTheClipboard->Close();
 
1833
}
 
1834
 
 
1835
void MyFrame::OnDialogFind ( wxFindDialogEvent& event )
 
1836
{
 
1837
        findAgain ( event.GetFindString(), event.GetFlags() );
 
1838
}
 
1839
 
 
1840
void MyFrame::OnDialogReplace ( wxFindDialogEvent& event )
 
1841
{
 
1842
        statusProgress ( wxEmptyString );
 
1843
        XmlDoc *doc;
 
1844
        if ( ( doc = getActiveDocument() ) == NULL )
 
1845
                return;
 
1846
 
 
1847
        int regexWidth = 0;
 
1848
        if ( findReplacePanel->getRegex() )
 
1849
        {
 
1850
                regexWidth = doc->ReplaceTargetRE ( event.GetReplaceString() );
 
1851
        }
 
1852
        else
 
1853
        {
 
1854
                doc->ReplaceTarget ( event.GetReplaceString() );
 
1855
        }
 
1856
        OnDialogFind ( event );
 
1857
}
 
1858
 
 
1859
void MyFrame::OnDialogReplaceAll ( wxFindDialogEvent& event )
 
1860
{
 
1861
        statusProgress ( wxEmptyString );
 
1862
        XmlDoc *doc;
 
1863
        if ( ( doc = getActiveDocument() ) == NULL )
 
1864
                return;
 
1865
 
 
1866
        int flags = 0;
 
1867
        if ( event.GetFlags() & wxFR_WHOLEWORD )
 
1868
                flags |= wxSTC_FIND_WHOLEWORD;
 
1869
        if ( event.GetFlags() & wxFR_MATCHCASE )
 
1870
                flags |= wxSTC_FIND_MATCHCASE;
 
1871
        if ( findReplacePanel->getRegex() )
 
1872
                flags |= wxSTC_FIND_REGEXP;
 
1873
 
 
1874
        doc->SetTargetStart ( 0 );
 
1875
        doc->SetTargetEnd ( doc->GetLength() );
 
1876
        doc->SetSearchFlags ( flags );
 
1877
 
 
1878
        int newLocation, replacementCount, regexWidth;
 
1879
        newLocation = replacementCount = regexWidth = 0;
 
1880
 
 
1881
        while ( ( newLocation = doc->SearchInTarget ( event.GetFindString() ) ) != -1 )
 
1882
        {
 
1883
                if ( findReplacePanel->getRegex() )
 
1884
                {
 
1885
                        regexWidth = doc->ReplaceTargetRE ( event.GetReplaceString() );
 
1886
                        doc->SetTargetStart ( newLocation + regexWidth );
 
1887
                }
 
1888
                else
 
1889
                {
 
1890
                        doc->ReplaceTarget ( event.GetReplaceString() );
 
1891
                        doc->SetTargetStart ( newLocation + event.GetReplaceString().size() );
 
1892
                }
 
1893
                doc->SetTargetEnd ( doc->GetLength() );
 
1894
                ++replacementCount;
 
1895
        }
 
1896
        wxString msg;
 
1897
 
 
1898
        msg.Printf (
 
1899
            ngettext ( L"%i replacement made", L"%i replacements made", replacementCount ),
 
1900
            replacementCount );
 
1901
        statusProgress ( msg );
 
1902
}
 
1903
 
 
1904
void MyFrame::OnPrintSetup ( wxCommandEvent &WXUNUSED ( event ) )
 
1905
{
 
1906
        if ( !htmlPrinting.get() )
 
1907
                return;
 
1908
        htmlPrinting->PageSetup();
 
1909
}
 
1910
 
 
1911
void MyFrame::OnPrintPreview ( wxCommandEvent &WXUNUSED ( event ) )
 
1912
{
 
1913
        XmlDoc *doc;
 
1914
        if ( !htmlPrinting.get() || ( doc = getActiveDocument() ) == NULL )
 
1915
                return;
 
1916
        wxString shortFileName, header;
 
1917
        shortFileName = doc->getShortFileName();
 
1918
        if ( !shortFileName.empty() )
 
1919
                header = shortFileName + _T ( " " );
 
1920
        header += _T ( "(@PAGENUM@/@PAGESCNT@)<hr>" );
 
1921
 
 
1922
        htmlPrinting->SetHeader (
 
1923
            header,
 
1924
            wxPAGE_ALL );
 
1925
        statusProgress ( _ ( "Preparing Print Preview..." ) );
 
1926
        wxString htmlBuffer = getHtmlBuffer();
 
1927
        statusProgress ( wxEmptyString );
 
1928
        if ( ! ( htmlPrinting->PreviewText ( htmlBuffer ) ) )
 
1929
                ;
 
1930
}
 
1931
 
 
1932
void MyFrame::OnPrint ( wxCommandEvent &WXUNUSED ( event ) )
 
1933
{
 
1934
        XmlDoc *doc;
 
1935
        if ( !htmlPrinting.get() || ( doc = getActiveDocument() ) == NULL )
 
1936
                return;
 
1937
        wxString shortFileName, header;
 
1938
        shortFileName = doc->getShortFileName();
 
1939
        if ( !shortFileName.empty() )
 
1940
                header = shortFileName + _T ( " " );
 
1941
        header += _T ( "(@PAGENUM@/@PAGESCNT@)<hr>" );
 
1942
 
 
1943
        htmlPrinting->SetHeader (
 
1944
            header,
 
1945
            wxPAGE_ALL );
 
1946
        statusProgress ( _ ( "Preparing to print..." ) );
 
1947
        wxString htmlBuffer = getHtmlBuffer();
 
1948
        statusProgress ( wxEmptyString );
 
1949
        if ( ! ( htmlPrinting->PrintText ( htmlBuffer ) ) )
 
1950
                ;
 
1951
}
 
1952
 
 
1953
wxString MyFrame::getHtmlBuffer()
 
1954
{
 
1955
        XmlDoc *doc;
 
1956
        if ( ( doc = getActiveDocument() ) == NULL )
 
1957
                return _T ( "<html><head></head><body></body></html>" );
 
1958
        wxString buffer, htmlBuffer;
 
1959
        buffer = doc->GetText();
 
1960
        size_t size = buffer.size();
 
1961
        htmlBuffer.reserve ( size * 2 );
 
1962
 
 
1963
        htmlBuffer = _T ( "<html><body><p>" );
 
1964
        bool startOfLine = true;
 
1965
        for ( size_t i = 0; i < size; ++i )
 
1966
        {
 
1967
                wchar_t c = buffer[i];
 
1968
                switch ( c )
 
1969
                {
 
1970
                        case L' ':
 
1971
                                htmlBuffer += ( startOfLine ) ? _T ( "&nbsp;" ) : _T ( " " );
 
1972
                                break;
 
1973
                        case L'\t':
 
1974
                                htmlBuffer += _T ( "&nbsp;&nbsp;" );
 
1975
                                break;
 
1976
                        case L'<':
 
1977
                                htmlBuffer += _T ( "&lt;" );
 
1978
                                startOfLine = false;
 
1979
                                break;
 
1980
                        case L'>':
 
1981
                                htmlBuffer += _T ( "&gt;" );
 
1982
                                startOfLine = false;
 
1983
                                break;
 
1984
                        case L'\n':
 
1985
                                htmlBuffer += _T ( "<br>" );
 
1986
                                startOfLine = true;
 
1987
                                break;
 
1988
                        case L'&':
 
1989
                                htmlBuffer + _T ( "&amp;" );
 
1990
                                startOfLine = false;
 
1991
                                break;
 
1992
                        default:
 
1993
                                htmlBuffer += c;
 
1994
                                startOfLine = false;
 
1995
                                break;
 
1996
                }
 
1997
        }
 
1998
        htmlBuffer += _T ( "</p></body></html>" );
 
1999
        return htmlBuffer;
 
2000
}
 
2001
 
 
2002
void MyFrame::OnFind ( wxCommandEvent& WXUNUSED ( event ) )
 
2003
{
 
2004
#ifdef NEWFINDREPLACE
 
2005
        manager.GetPane ( findReplacePanel ).Caption ( _ ( "Find" ) );
 
2006
        bool visible = manager.GetPane ( findReplacePanel ).IsShown();
 
2007
        if ( !visible )
 
2008
        {
 
2009
                manager.GetPane ( findReplacePanel ).Show();
 
2010
        }
 
2011
        manager.Update();
 
2012
        findReplacePanel->refresh();
 
2013
        findReplacePanel->setReplaceVisible ( false );
 
2014
        findReplacePanel->focusOnFind();
 
2015
        return;
 
2016
#endif
 
2017
 
 
2018
        if ( findDialog.get() )
 
2019
        {
 
2020
                findDialog = std::auto_ptr<wxFindReplaceDialog> ( 0 );
 
2021
        }
 
2022
        findDialog = ( std::auto_ptr<wxFindReplaceDialog> ( new wxFindReplaceDialog (
 
2023
                           this,
 
2024
                           &findData,
 
2025
                           _ ( "Find" ) ) ) );
 
2026
        findDialog->Show();
 
2027
}
 
2028
 
 
2029
void MyFrame::OnImportMSWord ( wxCommandEvent& event )
 
2030
{
 
2031
#ifndef __WXMSW__
 
2032
        messagePane ( _ ( "This functionality requires Microsoft Windows" ) );
 
2033
        return;
 
2034
#endif
 
2035
 
 
2036
        std::auto_ptr<wxFileDialog> fd ( new wxFileDialog (
 
2037
                                             this,
 
2038
                                             _ ( "Import Microsoft Word Document" ),
 
2039
                                             _T ( "" ),
 
2040
                                             _T ( "" ),
 
2041
                                             _T ( "Microsoft Word (*.doc)|*.doc" ),
 
2042
                                             wxOPEN | wxFILE_MUST_EXIST | wxCHANGE_DIR
 
2043
                                         ) );
 
2044
        if ( fd->ShowModal() == wxID_CANCEL )
 
2045
                return;
 
2046
 
 
2047
        wxString path = fd->GetPath();
 
2048
 
 
2049
        if ( path == _T ( "" ) )
 
2050
                return;
 
2051
 
 
2052
        importMSWord ( path );
 
2053
}
 
2054
 
 
2055
void MyFrame::OnExport ( wxCommandEvent& event )
 
2056
{
 
2057
        statusProgress ( wxEmptyString );
 
2058
        closePane();
 
2059
 
 
2060
        XmlDoc *doc;
 
2061
        if ( ( doc = getActiveDocument() ) == NULL )
 
2062
                return;
 
2063
 
 
2064
    wxString testDir = applicationDir + wxFileName::GetPathSeparator() + _T ( "daisy" );
 
2065
    bool downloadLink = !wxDirExists ( testDir );
 
2066
 
 
2067
    std::auto_ptr<ExportDialog> ed ( new ExportDialog (
 
2068
        this,
 
2069
        exportStylesheet,
 
2070
        exportFolder,
 
2071
        exportQuiet,
 
2072
        true, //suppressOptional
 
2073
        true, //html
 
2074
        true, //epub
 
2075
        true, //rtf
 
2076
        true, //doc
 
2077
        true, //fullDaisy
 
2078
        exportMp3Album,
 
2079
        downloadLink ) );
 
2080
    int ret = ed->ShowModal();
 
2081
    
 
2082
    if ( ret != wxID_OK )
 
2083
        return;
 
2084
 
 
2085
    exportStylesheet = ed->getUrlString();
 
2086
    exportFolder = ed->getFolderString();
 
2087
    exportQuiet = ed->getQuiet();
 
2088
    exportMp3Album = ed->getMp3Album();
 
2089
 
 
2090
        std::string rawBufferUtf8;
 
2091
        getRawText ( doc, rawBufferUtf8 );
 
2092
        if ( !XmlEncodingHandler::setUtf8 ( rawBufferUtf8 ) )
 
2093
        {
 
2094
                encodingMessage();
 
2095
                return;
 
2096
        }
 
2097
 
 
2098
        WrapTempFileName tempFileName ( doc->getFullFileName() );
 
2099
 
 
2100
        ofstream rawBufferStream ( tempFileName.name().c_str() );
 
2101
        if ( !rawBufferStream )
 
2102
                return;
 
2103
        rawBufferStream << rawBufferUtf8;
 
2104
        rawBufferStream.close();
 
2105
 
 
2106
    wxString tempFile= tempFileName.wideName();
 
2107
    
 
2108
    WrapDaisy wd ( this, daisyDir, doc->getFullFileName() );
 
2109
    if ( !wd.run ( tempFile, exportStylesheet, exportFolder, exportQuiet, exportMp3Album, true, true, true, true ) )
 
2110
    {
 
2111
        messagePane ( _ ("[b]DAISY export stopped[/b]: ") + wd.getLastError(), CONST_STOP );
 
2112
        return;
 
2113
    }
 
2114
        messagePane ( _ ( "DAISY export completed. Output files are stored in: [b]" ) + exportFolder + _T ( "[/b]." ), CONST_INFO );
 
2115
}
 
2116
 
 
2117
void MyFrame::importMSWord ( const wxString& path )
 
2118
{
 
2119
#ifndef __WXMSW__
 
2120
        messagePane ( _ ( "This functionality requires Microsoft Windows" ) );
 
2121
        return;
 
2122
#endif
 
2123
 
 
2124
        WrapTempFileName tempFileName ( _T ( "" ) ), swapFileName ( _T ( "" ) );
 
2125
        wxString completeSwapFileName = swapFileName.wideName() + _T ( ".doc" );
 
2126
        if ( !wxCopyFile ( path, completeSwapFileName, true ) )
 
2127
        {
 
2128
                wxString message;
 
2129
                message.Printf ( _ ( "Cannot open [b]%s[/b] for import" ), path.c_str() );
 
2130
                messagePane ( message, CONST_STOP );
 
2131
                return;
 
2132
        }
 
2133
 
 
2134
        wxString cmd = binDir +
 
2135
                       _T ( "doc2xml.exe \"" ) +
 
2136
                       completeSwapFileName + _T ( "\" \"" ) +
 
2137
                       tempFileName.wideName() + _T ( "\"" );
 
2138
 
 
2139
        statusProgress ( _ ( "Import in progress..." ) );
 
2140
        int result = wxExecute ( cmd, wxEXEC_SYNC );
 
2141
 
 
2142
        wxRemoveFile ( completeSwapFileName ); // necessary because .doc extension added
 
2143
 
 
2144
        statusProgress ( wxEmptyString );
 
2145
        wxString message;
 
2146
        wxString versionMessage (
 
2147
            _ ( "(lossless conversion requires version 2003 or later)" ) );
 
2148
 
 
2149
        switch ( result )
 
2150
        {
 
2151
                case 0:
 
2152
                        break;
 
2153
                case 1:
 
2154
                        messagePane ( _ ( "Cannot start Microsoft Word" ), CONST_STOP );
 
2155
                        return;
 
2156
                case 2:
 
2157
                        messagePane (
 
2158
                            _ ( "A more recent version of Microsoft Word is required" ), CONST_STOP );
 
2159
                        return;
 
2160
                case 3:
 
2161
                        message.Printf ( _T ( "Microsoft Word cannot open [b]%s[/b]" ), path.c_str() );
 
2162
                        messagePane ( message + path, CONST_STOP );
 
2163
                        return;
 
2164
                case 4:
 
2165
                        message.Printf ( _ ( "Microsoft Word cannot save [b]%s[/b] as XML" ), path.c_str() );
 
2166
                        messagePane ( message, CONST_STOP );
 
2167
                        return;
 
2168
                case 5:
 
2169
                        messagePane (
 
2170
                            _ ( "Microsoft Word cannot save this document as WordprocessingML " ) +
 
2171
                            versionMessage,
 
2172
                            CONST_INFO );
 
2173
                        break;
 
2174
                default:
 
2175
                        break;
 
2176
        }
 
2177
 
 
2178
        statusProgress ( _ ( "Opening imported file..." ) );
 
2179
        std::string buffer;
 
2180
 
 
2181
        wxString displayBuffer;
 
2182
 
 
2183
        if ( result != 5 ) // Word 2003 or later
 
2184
        {
 
2185
                std::auto_ptr<WrapLibxml> prettyPrinter ( new WrapLibxml ( libxmlNetAccess ) );
 
2186
                prettyPrinter->parse ( tempFileName.name(), true );
 
2187
                buffer = prettyPrinter->getOutput();
 
2188
                displayBuffer = wxString ( buffer.c_str(), wxConvUTF8, buffer.size() );
 
2189
        }
 
2190
        else // earlier versions
 
2191
        {
 
2192
                if ( !ReadFile::run ( tempFileName.name(), buffer ) )
 
2193
                {
 
2194
                        statusProgress ( wxEmptyString );
 
2195
                        messagePane ( _ ( "Cannot open imported file" ), CONST_STOP );
 
2196
                        return;
 
2197
                }
 
2198
                displayBuffer = wxString ( buffer.c_str(), wxConvUTF8, buffer.size() );
 
2199
                displayBuffer.Remove ( 0, 1 ); // remove byte order mark
 
2200
                xmliseWideTextNode ( displayBuffer );
 
2201
 
 
2202
                displayBuffer.Prepend (
 
2203
                    _T ( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>" ) );
 
2204
                displayBuffer.Append ( _T ( "</root>\n" ) );
 
2205
        }
 
2206
 
 
2207
        newDocument ( displayBuffer, tempFileName.wideName() );
 
2208
        statusProgress ( wxEmptyString );
 
2209
}
 
2210
 
 
2211
void MyFrame::OnExportMSWord ( wxCommandEvent& event )
 
2212
{
 
2213
#ifndef __WXMSW__
 
2214
        messagePane ( _ ( "This functionality requires Microsoft Windows" ) );
 
2215
        return;
 
2216
#endif
 
2217
        statusProgress ( wxEmptyString );
 
2218
 
 
2219
        // fetch document contents
 
2220
        XmlDoc *doc;
 
2221
        if ( ( doc = getActiveDocument() ) == NULL )
 
2222
                return;
 
2223
 
 
2224
        WrapTempFileName wtfn ( _T ( "" ) );
 
2225
        wxString sourceFileName = doc->getFullFileName();
 
2226
 
 
2227
        if ( sourceFileName.empty() )
 
2228
        {
 
2229
                sourceFileName = wtfn.wideName();
 
2230
                std::fstream ofs ( wtfn.name().c_str() );
 
2231
                if ( !ofs )
 
2232
                        return;
 
2233
 
 
2234
                std::string utf8Buffer;
 
2235
                getRawText ( doc, utf8Buffer );
 
2236
                ofs << utf8Buffer;
 
2237
                ofs.close();
 
2238
        }
 
2239
        else if ( doc->GetModify() ) //CanUndo())
 
2240
        {
 
2241
                modifiedMessage();
 
2242
                return;
 
2243
        }
 
2244
 
 
2245
        std::auto_ptr<wxFileDialog> fd ( new wxFileDialog (
 
2246
                                             this,
 
2247
                                             _ ( "Export Microsoft Word Document" ),
 
2248
                                             _T ( "" ),
 
2249
                                             _T ( "" ),
 
2250
                                             _T ( "Microsoft Word (*.doc)|*.doc" ),
 
2251
                                             wxSAVE | wxOVERWRITE_PROMPT ) );
 
2252
        fd->ShowModal();
 
2253
 
 
2254
        wxString path = fd->GetPath();
 
2255
 
 
2256
        if ( path == _T ( "" ) )
 
2257
                return;
 
2258
 
 
2259
        wxString cmd = binDir +
 
2260
                       _T ( "xml2doc.exe -v \"" ) +
 
2261
                       sourceFileName + _T ( "\" \"" ) +
 
2262
                       path + _T ( "\"" );
 
2263
 
 
2264
        statusProgress ( _ ( "Export in progress..." ) );
 
2265
        int result = wxExecute ( cmd, wxEXEC_SYNC );
 
2266
        statusProgress ( wxEmptyString );
 
2267
        wxString message;
 
2268
        switch ( result )
 
2269
        {
 
2270
                case 1:
 
2271
                        messagePane ( _ ( "Cannot start Microsoft Word" ), CONST_STOP );
 
2272
                        return;
 
2273
                case 2:
 
2274
                        messagePane (
 
2275
                            _ ( "A more recent version of Microsoft Word is required" ), CONST_STOP );
 
2276
                        return;
 
2277
                case 3:
 
2278
                        message.Printf ( _ ( "Microsoft Word cannot save %s" ), path.c_str() );
 
2279
                        messagePane ( message, CONST_STOP );
 
2280
                        return;
 
2281
                case 0:
 
2282
                        break;
 
2283
                default:
 
2284
                        break;
 
2285
        }
 
2286
}
 
2287
 
 
2288
void MyFrame::OnBrowser ( wxCommandEvent& WXUNUSED ( event ) )
 
2289
{
 
2290
        statusProgress ( wxEmptyString );
 
2291
 
 
2292
        // fetch document contents
 
2293
        XmlDoc *doc;
 
2294
        if ( ( doc = getActiveDocument() ) == NULL )
 
2295
                return;
 
2296
 
 
2297
        wxString sourceFileName = doc->getFullFileName();
 
2298
        WrapTempFileName wtfn ( sourceFileName, _T ( ".html" ) );
 
2299
 
 
2300
        if ( sourceFileName.empty() || doc->GetModify() )
 
2301
        {
 
2302
                sourceFileName = wtfn.wideName();
 
2303
 
 
2304
                std::ofstream ofs ( ( const char * ) wtfn.name().c_str() );
 
2305
                if ( !ofs )
 
2306
                {
 
2307
                        messagePane ( _ ( "Cannot save temporary file" ), CONST_STOP );
 
2308
                        return;
 
2309
                }
 
2310
 
 
2311
                std::string utf8Buffer;
 
2312
                getRawText ( doc, utf8Buffer );
 
2313
                ofs << utf8Buffer;
 
2314
                ofs.close();
 
2315
 
 
2316
                // keep files until application closes
 
2317
                tempFileVector.push_back ( sourceFileName );
 
2318
                tempFileVector.push_back ( wtfn.originalWideName() );
 
2319
                wtfn.setKeepFiles ( true );
 
2320
        }
 
2321
 
 
2322
        navigate ( sourceFileName );
 
2323
}
 
2324
 
 
2325
void MyFrame::OnHelp ( wxCommandEvent& event )
 
2326
{
 
2327
#ifdef __WXMSW__
 
2328
        wxString cmd = _T ( "hh.exe \"" ) + helpDir + _T ( "xmlcopyeditor.chm\"" );
 
2329
        wxExecute ( cmd );
 
2330
#else
 
2331
        wxString helpFileName = helpDir + _T ( "xmlcopyeditor.hhp" );
 
2332
        helpController->AddBook ( wxFileName ( helpFileName ) );
 
2333
        helpController->DisplayContents();
 
2334
#endif
 
2335
}
 
2336
 
 
2337
void MyFrame::OnSplitTab ( wxCommandEvent& event )
 
2338
{
 
2339
/*
 
2340
        int id = event.GetId();
 
2341
        XmlDoc *doc = getActiveDocument();
 
2342
        if ( !doc )
 
2343
                return;
 
2344
        wxString fileName = doc->getFullFileName();
 
2345
 
 
2346
        // mainBook->GetSelection() is currently unreliable, so fetch by title
 
2347
 
 
2348
            int pageCount = mainBook->GetPageCount();
 
2349
            XmlDoc *currentDoc;
 
2350
            int currentSelection = -1;
 
2351
            for ( int i = 0; i < pageCount; ++i )
 
2352
            {
 
2353
                currentDoc = ( XmlDoc * ) mainBook->GetPage ( i );
 
2354
                if ( !currentDoc )
 
2355
                    break;
 
2356
                if ( currentDoc->getFullFileName() == fileName )
 
2357
                {
 
2358
                    currentSelection = i;
 
2359
                }
 
2360
            }
 
2361
            if ( currentSelection == -1 )
 
2362
                return;
 
2363
        */
 
2364
        int currentSelection, direction;
 
2365
        currentSelection = mainBook->GetSelection();
 
2366
        direction = wxAUI_NB_RIGHT;
 
2367
/*
 
2368
        switch ( id )
 
2369
        {
 
2370
                            ID_SPLIT_TAB_TOP:
 
2371
                                direction = wxAUI_NB_TOP;
 
2372
                                break;
 
2373
                            ID_SPLIT_TAB_RIGHT:
 
2374
                                direction = wxAUI_NB_RIGHT;
 
2375
                                break;
 
2376
                            ID_SPLIT_TAB_BOTTOM:
 
2377
                                direction = wxAUI_NB_BOTTOM;
 
2378
                                break;
 
2379
                            ID_SPLIT_TAB_LEFT:
 
2380
                                direction = wxAUI_NB_LEFT;
 
2381
                                break;
 
2382
                default:
 
2383
                        direction = wxAUI_NB_RIGHT;
 
2384
                        break;
 
2385
        }
 
2386
*/
 
2387
        mainBook->Split ( currentSelection, direction );
 
2388
}
 
2389
 
 
2390
void MyFrame::OnColorScheme ( wxCommandEvent& event )
 
2391
{
 
2392
        int id = event.GetId();
 
2393
        switch ( id )
 
2394
        {
 
2395
                case ID_COLOR_SCHEME_DEFAULT:
 
2396
                        properties.colorScheme = COLOR_SCHEME_DEFAULT;
 
2397
                        break;
 
2398
                case ID_COLOR_SCHEME_DEFAULT_BACKGROUND:
 
2399
                        properties.colorScheme = COLOR_SCHEME_DEFAULT_BACKGROUND;
 
2400
                        break;
 
2401
                case ID_COLOR_SCHEME_REDUCED_GLARE:
 
2402
                        properties.colorScheme = COLOR_SCHEME_REDUCED_GLARE;
 
2403
                        break;
 
2404
                case ID_COLOR_SCHEME_NONE:
 
2405
                        properties.colorScheme = COLOR_SCHEME_NONE;
 
2406
                        break;
 
2407
                default:
 
2408
                        return;
 
2409
        }
 
2410
        colorSchemeMenu->Check ( id, true );
 
2411
 
 
2412
        XmlDoc *doc;
 
2413
        if ( ( doc = getActiveDocument() ) == NULL )
 
2414
                return;
 
2415
 
 
2416
        properties.zoom = doc->GetZoom(); // ensure temp changes to font size are kept
 
2417
 
 
2418
        applyEditorProperties ( false );
 
2419
        doc->SetFocus();
 
2420
}
 
2421
 
 
2422
void MyFrame::OnFontSmaller ( wxCommandEvent& event )
 
2423
{
 
2424
        XmlDoc *doc;
 
2425
        if ( ( doc = getActiveDocument() ) == NULL )
 
2426
                return;
 
2427
        doc->ZoomOut();
 
2428
        properties.zoom = doc->GetZoom();
 
2429
        applyEditorProperties ( true );
 
2430
        doc->SetFocus();
 
2431
}
 
2432
 
 
2433
void MyFrame::OnFontMedium ( wxCommandEvent& event )
 
2434
{
 
2435
        XmlDoc *doc;
 
2436
        if ( ( doc = getActiveDocument() ) == NULL )
 
2437
                return;
 
2438
        doc->SetZoom ( 0 );
 
2439
        properties.zoom = doc->GetZoom();
 
2440
        applyEditorProperties ( true );
 
2441
        doc->SetFocus();
 
2442
}
 
2443
 
 
2444
void MyFrame::OnFontLarger ( wxCommandEvent& event )
 
2445
{
 
2446
        XmlDoc *doc;
 
2447
        if ( ( doc = getActiveDocument() ) == NULL )
 
2448
                return;
 
2449
        doc->ZoomIn();
 
2450
        properties.zoom = doc->GetZoom();
 
2451
        applyEditorProperties ( true );
 
2452
        doc->SetFocus();
 
2453
}
 
2454
 
 
2455
void MyFrame::OnOptions ( wxCommandEvent& WXUNUSED ( event ) )
 
2456
{
 
2457
        // ensure font size does not change after
 
2458
        XmlDoc *doc = getActiveDocument();
 
2459
        if ( doc )
 
2460
        {
 
2461
                properties.zoom = doc->GetZoom();
 
2462
        }
 
2463
 
 
2464
        wxString title
 
2465
#ifdef __WXMSW__
 
2466
        ( _ ( "Options" ) );
 
2467
#else
 
2468
        ( _ ( "Preferences" ) );
 
2469
#endif
 
2470
        std::auto_ptr<MyPropertySheet> mpsd ( new MyPropertySheet (
 
2471
                                                  this,
 
2472
                                                  properties,
 
2473
                                                  applicationDir,
 
2474
                                                  browserCommand,
 
2475
                                                  rememberOpenTabs,
 
2476
                                                  libxmlNetAccess,
 
2477
                                                  singleInstanceCheck,
 
2478
                                                  saveBom,
 
2479
                                                  unlimitedUndo,
 
2480
                                                  restoreLayout,
 
2481
                                                  expandInternalEntities,
 
2482
                                                  showFullPathOnFrame,
 
2483
                                                  lang,
 
2484
                                                  wxID_ANY,
 
2485
                                                  title ) );
 
2486
        if ( mpsd->ShowModal() == wxID_OK )
 
2487
        {
 
2488
                properties = mpsd->getProperties();
 
2489
                applyEditorProperties();
 
2490
                applicationDir = mpsd->getApplicationDir();
 
2491
                browserCommand = mpsd->getBrowserCommand();
 
2492
                rememberOpenTabs = mpsd->getRememberOpenTabs();
 
2493
                libxmlNetAccess = mpsd->getLibxmlNetAccess();
 
2494
                singleInstanceCheck = mpsd->getSingleInstanceCheck();
 
2495
                saveBom = mpsd->getSaveBom();
 
2496
                unlimitedUndo = mpsd->getUnlimitedUndo();
 
2497
                restoreLayout = mpsd->getRestoreLayout();
 
2498
                expandInternalEntities = mpsd->getExpandInternalEntities();
 
2499
                showFullPathOnFrame = mpsd->getShowFullPathOnFrame();
 
2500
                lang = mpsd->getLang();
 
2501
                updatePaths();
 
2502
        }
 
2503
        if ( doc )
 
2504
                doc->SetFocus();
 
2505
}
 
2506
 
 
2507
void MyFrame::OnHistoryFile ( wxCommandEvent& event )
 
2508
{
 
2509
        wxString f ( history.GetHistoryFile ( event.GetId() - wxID_FILE1 ) );
 
2510
        if ( !f.empty() )
 
2511
                openFile ( f );
 
2512
}
 
2513
 
 
2514
void MyFrame::OnGoto ( wxCommandEvent& WXUNUSED ( event ) )
 
2515
{
 
2516
        statusProgress ( wxEmptyString );
 
2517
 
 
2518
        XmlDoc *doc;
 
2519
        if ( ( doc = getActiveDocument() ) == NULL )
 
2520
                return;
 
2521
 
 
2522
        wxTextEntryDialog *dlg = new wxTextEntryDialog (
 
2523
            this,
 
2524
            _ ( "Enter line number:" ),
 
2525
            _ ( "Go To" ) );
 
2526
        int ret = dlg->ShowModal();
 
2527
        if ( ret == wxID_CANCEL )
 
2528
                return;
 
2529
        wxString val = dlg->GetValue();
 
2530
        long line;
 
2531
        if ( !val.ToLong ( &line ) || line < 1 )
 
2532
        {
 
2533
                wxString msg;
 
2534
                msg.Printf ( _ ( "'%s' is not a valid line number" ), val.c_str() );
 
2535
                messagePane ( msg, CONST_STOP );
 
2536
                return;
 
2537
        }
 
2538
        --line;
 
2539
        doc->GotoLine ( ( int ) line );
 
2540
        doc->SetFocus();
 
2541
}
 
2542
 
 
2543
void MyFrame::OnFindAgain ( wxCommandEvent& event )
 
2544
{
 
2545
        //findAgain(findData.GetFindString(), findData.GetFlags());
 
2546
        findReplacePanel->OnFindNext ( event );
 
2547
}
 
2548
 
 
2549
void MyFrame::OnCommand ( wxCommandEvent& WXUNUSED ( event ) )
 
2550
{
 
2551
        bool visible = manager.GetPane ( commandPanel ).IsShown();
 
2552
        if ( !visible )
 
2553
        {
 
2554
                manager.GetPane ( commandPanel ).Show();
 
2555
        }
 
2556
        manager.Update();
 
2557
        commandPanel->focusOnCommand();
 
2558
}
 
2559
 
 
2560
void MyFrame::OnFindReplace ( wxCommandEvent& WXUNUSED ( event ) )
 
2561
{
 
2562
#ifdef NEWFINDREPLACE
 
2563
        manager.GetPane ( findReplacePanel ).Caption ( _ ( "Replace" ) );
 
2564
        bool visible = manager.GetPane ( findReplacePanel ).IsShown();
 
2565
        if ( !visible )
 
2566
        {
 
2567
                manager.GetPane ( findReplacePanel ).Show();
 
2568
        }
 
2569
        manager.Update();
 
2570
        findReplacePanel->refresh();
 
2571
        findReplacePanel->setReplaceVisible ( true );
 
2572
        findReplacePanel->focusOnFind();
 
2573
        return;
 
2574
#endif
 
2575
 
 
2576
 
 
2577
        if ( findDialog.get() )
 
2578
        {
 
2579
                findDialog = std::auto_ptr<wxFindReplaceDialog> ( 0 );
 
2580
        }
 
2581
        findDialog = std::auto_ptr<wxFindReplaceDialog> ( new wxFindReplaceDialog (
 
2582
                         this,
 
2583
                         &findData,
 
2584
                         _ ( "Find and Replace" ),
 
2585
                         wxFR_REPLACEDIALOG ) );
 
2586
        findDialog->Show();
 
2587
}
 
2588
 
 
2589
void MyFrame::OnGlobalReplace ( wxCommandEvent& event )
 
2590
{
 
2591
        XmlDoc *doc;
 
2592
        if ( ( doc = getActiveDocument() ) == NULL )
 
2593
                return;
 
2594
 
 
2595
        size_t flags = findData.GetFlags();
 
2596
        std::auto_ptr<GlobalReplaceDialog> grd ( new GlobalReplaceDialog (
 
2597
                    this,
 
2598
                    findData.GetFindString(),
 
2599
                    findData.GetReplaceString(),
 
2600
                    flags & wxFR_MATCHCASE,
 
2601
                    globalReplaceAllDocuments,
 
2602
                    findRegex ) );
 
2603
        int res = grd->ShowModal();
 
2604
 
 
2605
        flags = 0;
 
2606
        flags |= wxFR_DOWN;
 
2607
        if ( grd->getMatchCase() )
 
2608
                flags |= wxFR_MATCHCASE;
 
2609
        findRegex = grd->getRegex();
 
2610
        globalReplaceAllDocuments = grd->getAllDocuments();
 
2611
 
 
2612
        findData.SetFindString ( grd->getFindString() );
 
2613
        findData.SetReplaceString ( grd->getReplaceString() );
 
2614
        findData.SetFlags ( flags );
 
2615
        findReplacePanel->setRegex ( findRegex );
 
2616
        findReplacePanel->setMatchCase ( flags & wxFR_MATCHCASE );
 
2617
        findReplacePanel->refresh();
 
2618
 
 
2619
        if ( res != wxID_OK )
 
2620
        {
 
2621
                return;
 
2622
        }
 
2623
 
 
2624
        int globalMatchCount, pageCount;
 
2625
        globalMatchCount = 0;
 
2626
        pageCount = mainBook->GetPageCount();
 
2627
        XmlDoc *currentDoc = getActiveDocument();
 
2628
        if ( !currentDoc )
 
2629
                return;
 
2630
 
 
2631
        for ( int i = 0; i < pageCount; ++i )
 
2632
        {
 
2633
                std::string bufferUtf8;
 
2634
                if ( !globalReplaceAllDocuments )
 
2635
                {
 
2636
                        getRawText ( currentDoc, bufferUtf8 );
 
2637
                }
 
2638
                else
 
2639
                {
 
2640
                        currentDoc = ( XmlDoc * ) mainBook->GetPage ( i );
 
2641
                        if ( !currentDoc )
 
2642
                                return;
 
2643
                        getRawText ( currentDoc, bufferUtf8 );
 
2644
                }
 
2645
 
 
2646
                size_t flags = findData.GetFlags();
 
2647
                if ( !findRegex )
 
2648
                {
 
2649
                        std::string findUtf8, replaceUtf8;
 
2650
                        findUtf8 =findData.GetFindString().mb_str ( wxConvUTF8 );
 
2651
                        replaceUtf8 = findData.GetReplaceString().mb_str ( wxConvUTF8 );
 
2652
                        globalMatchCount += Replace::run (
 
2653
                                                bufferUtf8,
 
2654
                                                findUtf8,
 
2655
                                                replaceUtf8,
 
2656
                                                flags & wxFR_MATCHCASE );
 
2657
                        currentDoc->SetTextRaw ( bufferUtf8.c_str() );
 
2658
                        currentDoc->setValidationRequired ( true );
 
2659
                }
 
2660
                else
 
2661
                {
 
2662
                        try
 
2663
                        {
 
2664
                                std::auto_ptr<WrapRegex> wr ( new WrapRegex (
 
2665
                                                                  ( const char * ) findData.GetFindString().mb_str ( wxConvUTF8 ),
 
2666
                                                                  flags & wxFR_MATCHCASE,
 
2667
                                                                  ( const char * ) findData.GetReplaceString().mb_str ( wxConvUTF8 ) ) );
 
2668
 
 
2669
                                int matchCount;
 
2670
                                std::string outputBuffer = wr->replaceGlobal ( bufferUtf8, &matchCount );
 
2671
                                globalMatchCount += matchCount;
 
2672
                                currentDoc->SetTextRaw ( outputBuffer.c_str() );
 
2673
                                currentDoc->setValidationRequired ( true );
 
2674
                        }
 
2675
                        catch ( std::exception& e )
 
2676
                        {
 
2677
                                wxString wideError = wxString ( e.what(), wxConvUTF8, strlen ( e.what() ) );
 
2678
                                messagePane ( _ ( "Cannot replace: " ) + wideError, CONST_STOP );
 
2679
                                return;
 
2680
                        }
 
2681
                }
 
2682
                if ( !globalReplaceAllDocuments )
 
2683
                        break;
 
2684
        }
 
2685
        wxString msg;
 
2686
 
 
2687
        msg.Printf (
 
2688
            ngettext ( L"%i replacement made", L"%i replacements made", globalMatchCount ),
 
2689
            globalMatchCount );
 
2690
 
 
2691
        statusProgress ( msg );
 
2692
}
 
2693
 
 
2694
void MyFrame::OnFrameClose ( wxCloseEvent& event )
 
2695
{
 
2696
        wxCommandEvent e;
 
2697
        OnCloseAll ( e );
 
2698
        if ( mainBook->GetPageCount() )
 
2699
        {
 
2700
                event.Veto();
 
2701
                return;
 
2702
        }
 
2703
        event.Skip();
 
2704
}
 
2705
 
 
2706
void MyFrame::OnNew ( wxCommandEvent& WXUNUSED ( event ) )
 
2707
{
 
2708
        wxString defaultSelection, typeSelection, templateFile;
 
2709
        defaultSelection = _ ( "XML document (*.xml)" );
 
2710
        wxArrayString templateArray;
 
2711
        if ( wxFileName::DirExists ( templateDir ) )
 
2712
        {
 
2713
                wxString templateMask, name, extension, entry;
 
2714
                templateMask = templateDir + wxFileName::GetPathSeparator() + _T ( "*.*" );
 
2715
                templateFile = wxFindFirstFile ( templateMask, wxFILE );
 
2716
                wxFileName fn;
 
2717
 
 
2718
                if ( !templateFile.empty() )
 
2719
                {
 
2720
                        fn.Assign ( templateFile );
 
2721
                        name = fn.GetName();
 
2722
                        extension = fn.GetExt();
 
2723
 
 
2724
                        entry.Printf ( _T ( "%s (*.%s)" ), name.c_str(), extension.c_str() );
 
2725
                        templateArray.Add ( entry );
 
2726
 
 
2727
                        for ( ;; )
 
2728
                        {
 
2729
                                templateFile = wxFindNextFile();
 
2730
                                if ( templateFile.empty() )
 
2731
                                        break;
 
2732
                                fn.Assign ( templateFile );
 
2733
                                name = fn.GetName();
 
2734
                                extension = fn.GetExt();
 
2735
 
 
2736
                                entry.Printf ( _T ( "%s (*.%s)" ), name.c_str(), extension.c_str() );
 
2737
                                templateArray.Add ( entry );
 
2738
                        }
 
2739
                }
 
2740
                templateArray.Sort();
 
2741
                templateArray.Insert ( defaultSelection, 0 );
 
2742
 
 
2743
                const int arraySize = templateArray.GetCount();
 
2744
 
 
2745
                wxString choiceArray[arraySize + 1];
 
2746
                for ( int i = 0; i < arraySize; ++i )
 
2747
                        * ( choiceArray + i ) = templateArray.Item ( i );
 
2748
 
 
2749
                wxSingleChoiceDialog scd (
 
2750
                    this, _ ( "Choose a document type:" ), _ ( "New Document" ), arraySize, choiceArray );
 
2751
                if ( scd.ShowModal() == wxID_CANCEL )
 
2752
                {
 
2753
                        XmlDoc *doc = getActiveDocument();
 
2754
                        if ( doc )
 
2755
                                doc->SetFocus();
 
2756
                        return;
 
2757
                }
 
2758
                typeSelection = scd.GetStringSelection();
 
2759
        }
 
2760
 
 
2761
        if ( typeSelection == defaultSelection )
 
2762
        {
 
2763
                wxString emptyString ( _T ( "" ) );
 
2764
                newDocument ( emptyString );
 
2765
                return;
 
2766
        }
 
2767
 
 
2768
        typeSelection.Replace ( _T ( " (*" ), wxEmptyString );
 
2769
        typeSelection.Replace ( _T ( ")" ), wxEmptyString );
 
2770
        templateFile = templateDir + typeSelection;
 
2771
        std::string templateFileLocal, buffer;
 
2772
        templateFileLocal = templateFile.mb_str ( wxConvLocal );
 
2773
        ReadFile::run ( templateFileLocal, buffer );
 
2774
        wxString documentContents = wxString ( buffer.c_str(), wxConvUTF8, buffer.size() );
 
2775
 
 
2776
        newDocument ( documentContents,
 
2777
                      wxString ( templateFileLocal.c_str(), wxConvUTF8, templateFileLocal.size() ) );
 
2778
}
 
2779
 
 
2780
void MyFrame::newDocument ( const wxString& s, const wxString& path, bool canSave )
 
2781
{
 
2782
        std::string bufferUtf8 = ( const char * ) s.mb_str ( wxConvUTF8 );
 
2783
        std::string pathUtf8 = ( const char * ) path.mb_str ( wxConvUTF8 );
 
2784
        newDocument ( bufferUtf8, pathUtf8, canSave );
 
2785
}
 
2786
 
 
2787
void MyFrame::newDocument ( const std::string& s, const std::string& path, bool canSave )
 
2788
{
 
2789
        XmlDoc *doc;
 
2790
 
 
2791
        wxString documentLabel;
 
2792
        documentLabel.Printf ( _ ( "Document%i" ), documentCount++ );
 
2793
 
 
2794
        std::string auxPath = getAuxPath ( path );
 
2795
 
 
2796
        Freeze();
 
2797
        doc = ( s.empty() ) ?
 
2798
              new XmlDoc (
 
2799
                  mainBook,
 
2800
                  properties,
 
2801
                  &protectTags,
 
2802
                  visibilityState,
 
2803
                  FILE_TYPE_XML,
 
2804
                  wxID_ANY,
 
2805
                  NULL, 0 // new: NULL pointer leads to default document
 
2806
              )
 
2807
              : new XmlDoc (
 
2808
                  mainBook,
 
2809
                  properties,
 
2810
                  &protectTags,
 
2811
                  visibilityState,
 
2812
                  FILE_TYPE_XML,
 
2813
                  wxID_ANY,
 
2814
                  s.c_str(), // modified
 
2815
                  s.size(), // new
 
2816
                  catalogPath,
 
2817
                  catalogUtilityPath,
 
2818
                  path,
 
2819
                  auxPath );
 
2820
        mainBook->AddPage ( ( wxWindow * ) doc, documentLabel, true );
 
2821
        Thaw();
 
2822
 
 
2823
        mainBook->Refresh();
 
2824
        if ( properties.completion )
 
2825
                doc->updatePromptMaps();
 
2826
        doc->setShortFileName ( documentLabel );
 
2827
        doc->SetFocus();
 
2828
        manager.Update();
 
2829
        locationPanel->update ( doc, wxEmptyString );
 
2830
        insertChildPanel->update ( doc, wxEmptyString );
 
2831
        insertSiblingPanel->update ( doc, wxEmptyString );
 
2832
        insertEntityPanel->update ( doc );
 
2833
        if ( properties.validateAsYouType )
 
2834
                doc->backgroundValidate();
 
2835
}
 
2836
 
 
2837
void MyFrame::OnOpen ( wxCommandEvent& event )
 
2838
{
 
2839
        bool largeFile;
 
2840
        largeFile = ( event.GetId() == ID_OPEN_LARGE_FILE );
 
2841
 
 
2842
        wxString defaultFile, defaultDir;
 
2843
        XmlDoc *doc;
 
2844
        if ( ( doc = getActiveDocument() ) != NULL )
 
2845
        {
 
2846
                defaultFile = doc->getFullFileName();
 
2847
                if ( !defaultFile.empty() )
 
2848
                {
 
2849
                        wxFileName fn ( defaultFile );
 
2850
                        defaultDir = fn.GetPath();
 
2851
                }
 
2852
        }
 
2853
 
 
2854
        wxFileDialog *fd = new wxFileDialog (
 
2855
            this,
 
2856
            ( largeFile ) ? _ ( "Open Large Document" ) : _ ( "Open" ),
 
2857
            defaultDir,
 
2858
            wxEmptyString,
 
2859
            FILE_FILTER,
 
2860
            wxOPEN | wxMULTIPLE | wxFILE_MUST_EXIST | wxCHANGE_DIR
 
2861
        );
 
2862
 
 
2863
 
 
2864
        if ( fd->ShowModal() == wxID_CANCEL )
 
2865
                return;
 
2866
 
 
2867
        wxArrayString paths;
 
2868
        fd->GetPaths ( paths );
 
2869
        size_t count = paths.Count();
 
2870
        if ( !count )
 
2871
                return;
 
2872
        for ( size_t i = 0; i < count; ++i )
 
2873
                if ( !openFile ( paths[i], largeFile ) )
 
2874
                        break;
 
2875
}
 
2876
 
 
2877
bool MyFrame::openFile ( wxString& fileName, bool largeFile )
 
2878
{
 
2879
#ifndef __WXMSW__
 
2880
        // truncate string up to file:/ portion added by GNOME
 
2881
        wxString filePrefix = _T ( "file:" );
 
2882
        int index = fileName.Find ( filePrefix.c_str() );
 
2883
        if ( index != -1 )
 
2884
        {
 
2885
                fileName = fileName.Mid ( ( size_t ) index + filePrefix.Length() );
 
2886
        }
 
2887
#endif
 
2888
 
 
2889
        if ( !wxFileName::FileExists ( fileName ) )
 
2890
        {
 
2891
                wxString message;
 
2892
                message.Printf ( _ ( "Cannot open %s." ), fileName.c_str() );
 
2893
                messagePane ( message, CONST_STOP );
 
2894
                return false;
 
2895
        }
 
2896
 
 
2897
        if ( openFileSet.count ( fileName ) )
 
2898
        {
 
2899
                wxString message;
 
2900
                message.Printf ( _ ( "%s is already open" ), fileName.c_str() );
 
2901
                statusProgress ( message );
 
2902
                activateTab ( fileName );
 
2903
                return false;
 
2904
        }
 
2905
 
 
2906
        wxString directory, name, extension;
 
2907
        wxFileName::SplitPath ( fileName, NULL, &directory, &name, &extension );
 
2908
 
 
2909
        if ( !extension.empty() )
 
2910
        {
 
2911
                name += _T ( "." );
 
2912
                name += extension;
 
2913
        }
 
2914
 
 
2915
        wxString wideError;
 
2916
        std::string buffer;
 
2917
        pair<int, int> posPair;
 
2918
        XmlDoc *doc;
 
2919
 
 
2920
        int type = getFileType ( fileName );
 
2921
        std::string auxPath = getAuxPath ( ( const char * ) fileName.mb_str ( wxConvLocal ) );
 
2922
 
 
2923
        char *docBuffer = 0;
 
2924
        size_t docBufferLen = 0;
 
2925
        bool fileEmpty = false;
 
2926
 
 
2927
        statusProgress ( _T ( "Opening file..." ) );
 
2928
        //wxMemoryMappedFile *memorymap = NULL;
 
2929
        BinaryFile *binaryfile = NULL;
 
2930
 
 
2931
        binaryfile = new BinaryFile ( ( const char * ) fileName.mb_str ( wxConvLocal ) );
 
2932
        if ( !binaryfile->getData() )
 
2933
        {
 
2934
                wxString message;
 
2935
                message.Printf ( _ ( "Cannot open %s" ), fileName.c_str() );
 
2936
                messagePane ( message, CONST_STOP );
 
2937
                statusProgress ( wxEmptyString );
 
2938
                return false;
 
2939
        }
 
2940
        /*
 
2941
            memorymap = new wxMemoryMappedFile(
 
2942
              fileName,
 
2943
              true, // readOnly
 
2944
              true // fread
 
2945
            );
 
2946
        */
 
2947
 
 
2948
        /*
 
2949
          catch (wxMemoryMappedFileEmptyException&)
 
2950
          {
 
2951
            fileEmpty = true;
 
2952
          }
 
2953
        */
 
2954
 
 
2955
        bool isUtf8 = false;
 
2956
 
 
2957
        if ( !fileEmpty )
 
2958
        {
 
2959
                docBuffer = ( char * ) binaryfile->getData();//memorymap->GetStream();
 
2960
                docBufferLen = binaryfile->getDataLen();//memorymap->GetMapSize();
 
2961
        }
 
2962
        else
 
2963
        {
 
2964
                docBuffer = NULL;
 
2965
                docBufferLen = 0;
 
2966
                isUtf8 = true;
 
2967
        }
 
2968
 
 
2969
        statusProgress ( wxEmptyString );
 
2970
 
 
2971
        char *iconvBuffer = 0;
 
2972
        size_t iconvBufferLen = 0;
 
2973
 
 
2974
        char *finalBuffer;
 
2975
        size_t finalBufferLen;
 
2976
 
 
2977
        // adjust for UTF-8 BOM
 
2978
        if ( docBuffer &&
 
2979
                ( unsigned char ) docBuffer[0] == 0xEF &&
 
2980
                ( unsigned char ) docBuffer[1] == 0xBB &&
 
2981
                ( unsigned char ) docBuffer[2] == 0xBF )
 
2982
        {
 
2983
                docBuffer += 3;
 
2984
                docBufferLen -= 3;
 
2985
                isUtf8 = true;
 
2986
        }
 
2987
 
 
2988
        // no UTF-8 BOM found
 
2989
        std::string encoding;
 
2990
        if ( !isUtf8 || !binaryfile->getDataLen() )
 
2991
        {
 
2992
                XmlEncodingSpy es;
 
2993
                es.parse ( docBuffer, docBufferLen );
 
2994
                encoding = es.getEncoding();
 
2995
                if ( encoding == "UTF-8" ||
 
2996
                        encoding == "utf-8" ||
 
2997
                        encoding == "US-ASCII" ||
 
2998
                        encoding == "us-ascii" ) // US-ASCII is a subset of UTF-8
 
2999
                        isUtf8 = true;
 
3000
        }
 
3001
 
 
3002
        // convert buffer if not UTF-8
 
3003
        if ( isUtf8 )
 
3004
        {
 
3005
                finalBuffer = docBuffer;
 
3006
                finalBufferLen = docBufferLen;
 
3007
        }
 
3008
        else
 
3009
        {
 
3010
                // clear any other BOMs
 
3011
 
 
3012
                if ( docBuffer && // UTF-32 BE
 
3013
                        ( unsigned char ) docBuffer[0] == 0x00 &&
 
3014
                        ( unsigned char ) docBuffer[1] == 0x00 &&
 
3015
                        ( unsigned char ) docBuffer[2] == 0xFE &&
 
3016
                        ( unsigned char ) docBuffer[3] == 0xFF )
 
3017
                {
 
3018
                        docBuffer += 4;
 
3019
                        docBufferLen -= 4;
 
3020
                }
 
3021
                if ( docBuffer && // UTF-32 LE
 
3022
                        ( unsigned char ) docBuffer[0] == 0xFF &&
 
3023
                        ( unsigned char ) docBuffer[1] == 0xFE &&
 
3024
                        ( unsigned char ) docBuffer[2] == 0x00 &&
 
3025
                        ( unsigned char ) docBuffer[3] == 0x00 )
 
3026
                {
 
3027
                        docBuffer += 4;
 
3028
                        docBufferLen -= 4;
 
3029
                }
 
3030
 
 
3031
                if ( docBuffer && //UTF-16 BE
 
3032
                        ( unsigned char ) docBuffer[0] == 0xFE &&
 
3033
                        ( unsigned char ) docBuffer[1] == 0xFF )
 
3034
                {
 
3035
                        docBuffer += 2;
 
3036
                        docBufferLen -= 2;
 
3037
                }
 
3038
                if ( docBuffer && //UTF-16 LE
 
3039
                        ( unsigned char ) docBuffer[0] == 0xFF &&
 
3040
                        ( unsigned char ) docBuffer[1] == 0xFE )
 
3041
                {
 
3042
                        docBuffer += 2;
 
3043
                        docBufferLen -= 2;
 
3044
                }
 
3045
 
 
3046
                if ( !encoding.size() ) // Expat couldn't parse file (e.g. UTF-32)
 
3047
                {
 
3048
                        encoding = getApproximateEncoding ( docBuffer, docBufferLen );
 
3049
                }
 
3050
 
 
3051
                wxString wideEncoding = wxString (
 
3052
                                            encoding.c_str(),
 
3053
                                            wxConvLocal,
 
3054
                                            encoding.size() );
 
3055
                iconv_t cd = iconv_open ( "UTF-8", encoding.c_str() );
 
3056
                if ( cd == ( iconv_t )-1 )
 
3057
                {
 
3058
                        wxString message;
 
3059
                        message.Printf ( _ ( "Cannot open %s: unknown encoding %s" ),
 
3060
                                         fileName.c_str(),
 
3061
                                         wideEncoding.c_str() );
 
3062
                        messagePane ( message, CONST_STOP );
 
3063
                        delete binaryfile;//memorymap;
 
3064
                        return false;
 
3065
                };
 
3066
 
 
3067
                int iconvLenMultiplier = 4; // worst case scenario
 
3068
                if ( encoding == "ISO-8859-1" ||
 
3069
                        encoding == "UTF-16" ||
 
3070
                        encoding == "UTF-16BE" ||
 
3071
                        encoding == "UTF-16LE" )
 
3072
                {
 
3073
                        iconvLenMultiplier = 2;
 
3074
                }
 
3075
                else if ( encoding == "UTF-32" ||
 
3076
                          encoding == "UTF-32BE" ||
 
3077
                          encoding == "UTF-32LE" )
 
3078
                {
 
3079
                        iconvLenMultiplier = 1;
 
3080
                }
 
3081
 
 
3082
                size_t iconvBufferLeft, docBufferLeft;
 
3083
                iconvBufferLen = iconvBufferLeft = docBufferLen * iconvLenMultiplier + 1;
 
3084
                docBufferLeft = docBufferLen;
 
3085
                iconvBuffer = new char[iconvBufferLen];
 
3086
                finalBuffer = iconvBuffer; // iconvBuffer will be incremented by iconv
 
3087
                size_t nconv;
 
3088
 
 
3089
                nconv = iconv (
 
3090
                            cd,
 
3091
#ifdef __WXMSW__
 
3092
                            ( const char ** )
 
3093
#endif
 
3094
                            &docBuffer,
 
3095
                            &docBufferLeft,
 
3096
                            &iconvBuffer,
 
3097
                            &iconvBufferLeft );
 
3098
 
 
3099
                *iconvBuffer = '\0';
 
3100
 
 
3101
                iconv_close ( cd );
 
3102
 
 
3103
                if ( nconv == ( size_t )-1 )
 
3104
                {
 
3105
                        wxString message;
 
3106
                        message.Printf ( _ ( "Cannot open %s: conversion from encoding %s failed" ),
 
3107
                                         fileName.c_str(),
 
3108
                                         wideEncoding.c_str() );
 
3109
                        messagePane ( message, CONST_STOP );
 
3110
                        delete[] finalBuffer;
 
3111
                        delete binaryfile; //delete memorymap;
 
3112
                        return false;
 
3113
                }
 
3114
                finalBufferLen = iconvBufferLen - iconvBufferLeft;
 
3115
        }
 
3116
 
 
3117
        statusProgress ( _ ( "Creating document view..." ) );
 
3118
        Freeze();
 
3119
        doc = new XmlDoc (
 
3120
            mainBook,
 
3121
            ( largeFile ) ? largeFileProperties: properties,
 
3122
            &protectTags,
 
3123
            visibilityState,
 
3124
            ( !binaryfile->getDataLen() ) ? FILE_TYPE_XML : type,
 
3125
            wxID_ANY,
 
3126
            finalBuffer,
 
3127
            finalBufferLen,
 
3128
            catalogPath,
 
3129
            catalogUtilityPath,
 
3130
            ( const char * ) fileName.mb_str ( wxConvLocal ),
 
3131
            auxPath );
 
3132
#ifdef __WXMSW__
 
3133
        doc->SetUndoCollection ( false );
 
3134
        doc->SetUndoCollection ( true );
 
3135
#endif
 
3136
 
 
3137
        doc->setFullFileName ( fileName );
 
3138
        doc->setShortFileName ( name );
 
3139
        doc->setDirectory ( directory );
 
3140
        openFileSet.insert ( fileName );
 
3141
        history.AddFileToHistory ( fileName );
 
3142
        updateFileMenu();
 
3143
        wxFileName ofn ( fileName );
 
3144
        doc->setLastModified ( ofn.GetModificationTime() );
 
3145
 
 
3146
        mainBook->AddPage ( ( wxWindow * ) doc, name, _T ( "" ) );
 
3147
        Thaw();
 
3148
        statusProgress ( wxEmptyString );
 
3149
 
 
3150
        mainBook->Refresh();
 
3151
 
 
3152
        wxFileName fn ( fileName );
 
3153
        doc->setLastModified ( fn.GetModificationTime() );
 
3154
        doc->SetFocus();
 
3155
 
 
3156
        if ( type != FILE_TYPE_XML || !binaryfile->getDataLen() )
 
3157
        {
 
3158
                delete binaryfile;//memorymap;
 
3159
                return true;
 
3160
        }
 
3161
 
 
3162
        // NOW parse the document, but don't create a UTF-8 copy
 
3163
        statusProgress ( _T ( "Parsing document..." ) );
 
3164
        std::auto_ptr<WrapExpat> we ( new WrapExpat() );
 
3165
 
 
3166
        bool optimisedParseSuccess = false;
 
3167
 
 
3168
        // omit XML declaration
 
3169
        if ( !isUtf8 && finalBufferLen &&
 
3170
                finalBuffer[0] == '<' &&
 
3171
                finalBuffer[1] == '?' &&
 
3172
                finalBuffer[2] == 'x' &&
 
3173
                finalBuffer[3] == 'm' &&
 
3174
                finalBuffer[4] == 'l' )
 
3175
        {
 
3176
                for ( ; *finalBuffer && finalBufferLen; finalBuffer++ && finalBufferLen-- )
 
3177
                {
 
3178
                        if ( *finalBuffer == '>' )
 
3179
                        {
 
3180
                                finalBuffer++;
 
3181
                                finalBufferLen--;
 
3182
                                break;
 
3183
                        }
 
3184
                }
 
3185
        }
 
3186
 
 
3187
        if ( finalBuffer )
 
3188
        {
 
3189
                optimisedParseSuccess = we->parse ( finalBuffer, finalBufferLen );
 
3190
                statusProgress ( wxEmptyString );
 
3191
        }
 
3192
 
 
3193
        // NOW update prompt maps if necessary
 
3194
        if ( !largeFile && ( properties.completion || properties.validateAsYouType ) )
 
3195
        {
 
3196
                statusProgress ( _T ( "Compiling autocompletion lists..." ) );
 
3197
                doc->updatePromptMaps ( finalBuffer, finalBufferLen );
 
3198
                statusProgress ( wxEmptyString );
 
3199
        }
 
3200
 
 
3201
        if ( !largeFile && ( properties.validateAsYouType && doc->getGrammarFound() ) )
 
3202
        {
 
3203
                statusProgress ( _T ( "Validating document..." ) );
 
3204
                //doc->backgroundValidate ( finalBuffer, doc->getFullFileName().mb_str(wxConvUTF8), finalBufferLen );
 
3205
                doc->backgroundValidate();
 
3206
                statusProgress ( wxEmptyString );
 
3207
        }
 
3208
 
 
3209
        if ( !optimisedParseSuccess )
 
3210
        {
 
3211
                std::string error = we->getLastError();
 
3212
                wideError = wxString ( error.c_str(), wxConvUTF8, error.size() );
 
3213
                posPair = we->getErrorPosition();
 
3214
                -- ( posPair.first );
 
3215
                messagePane ( wideError, CONST_WARNING );
 
3216
 
 
3217
                int newPosition = doc->PositionFromLine ( posPair.first );
 
3218
                doc->SetSelection ( newPosition, newPosition );
 
3219
                doc->SetFocus();
 
3220
        }
 
3221
        else
 
3222
        {
 
3223
                closePane();
 
3224
        }
 
3225
        delete binaryfile; //delete memorymap;
 
3226
        return true;
 
3227
}
 
3228
 
 
3229
std::string MyFrame::getApproximateEncoding ( char *docBuffer,
 
3230
        size_t docBufferLen )
 
3231
{
 
3232
        std::string line, encoding;
 
3233
        char *it;
 
3234
        size_t i;
 
3235
 
 
3236
        // grab first line
 
3237
        for (
 
3238
            i = 0, it = docBuffer;
 
3239
            i < docBufferLen && *it != '\n' && i < BUFSIZ;
 
3240
            i++, it++ )
 
3241
        {
 
3242
                if ( *it )
 
3243
                        line += *it;
 
3244
        }
 
3245
 
 
3246
        std::pair<int, int> limits = XmlEncodingHandler::getEncodingValueLimits ( line );
 
3247
 
 
3248
        if ( limits.first == -1 || limits.second == -1 )
 
3249
                return "";
 
3250
 
 
3251
        return line.substr ( limits.first, limits.second );
 
3252
}
 
3253
 
 
3254
void MyFrame::OnToggleFold ( wxCommandEvent& WXUNUSED ( event ) )
 
3255
{
 
3256
        XmlDoc *doc;
 
3257
        if ( ( doc = getActiveDocument() ) == NULL )
 
3258
                return;
 
3259
        doc->toggleFold();
 
3260
}
 
3261
 
 
3262
void MyFrame::OnFoldAll ( wxCommandEvent& WXUNUSED ( event ) )
 
3263
{
 
3264
        XmlDoc *doc;
 
3265
        if ( ( doc = getActiveDocument() ) == NULL )
 
3266
                return;
 
3267
        doc->foldAll();
 
3268
        doc->SetFocus();
 
3269
}
 
3270
 
 
3271
void MyFrame::OnUnfoldAll ( wxCommandEvent& WXUNUSED ( event ) )
 
3272
{
 
3273
        XmlDoc *doc;
 
3274
        if ( ( doc = getActiveDocument() ) == NULL )
 
3275
                return;
 
3276
        doc->unfoldAll();
 
3277
        doc->SetFocus();
 
3278
}
 
3279
 
 
3280
 
 
3281
void MyFrame::OnQuit ( wxCommandEvent& WXUNUSED ( event ) )
 
3282
{
 
3283
        Close ( true );
 
3284
}
 
3285
 
 
3286
void MyFrame::OnUndo ( wxCommandEvent& WXUNUSED ( event ) )
 
3287
{
 
3288
        XmlDoc *doc;
 
3289
        if ( ( doc = getActiveDocument() ) == NULL )
 
3290
                return;
 
3291
        doc->Undo();
 
3292
        doc->setValidationRequired ( true );
 
3293
        doc->SetFocus();
 
3294
}
 
3295
 
 
3296
void MyFrame::OnRedo ( wxCommandEvent& WXUNUSED ( event ) )
 
3297
{
 
3298
        XmlDoc *doc;
 
3299
        if ( ( doc = getActiveDocument() ) == NULL )
 
3300
                return;
 
3301
        doc->Redo();
 
3302
        doc->setValidationRequired ( true );
 
3303
        doc->SetFocus();
 
3304
}
 
3305
 
 
3306
void MyFrame::OnRevert ( wxCommandEvent& WXUNUSED ( event ) )
 
3307
{
 
3308
        XmlDoc *doc;
 
3309
        if ( ( doc = getActiveDocument() ) == NULL )
 
3310
                return;
 
3311
 
 
3312
        while ( doc->GetModify() )
 
3313
        {
 
3314
                if ( !doc->CanUndo() )
 
3315
                        return;
 
3316
                doc->Undo();
 
3317
                doc->setValidationRequired ( true );
 
3318
        }
 
3319
        doc->SetFocus();
 
3320
}
 
3321
 
 
3322
void MyFrame::OnSpelling ( wxCommandEvent& event )
 
3323
{
 
3324
        XmlDoc *doc;
 
3325
        if ( ( doc = getActiveDocument() ) == NULL )
 
3326
                return;
 
3327
 
 
3328
        statusProgress ( wxEmptyString );
 
3329
        closePane();
 
3330
 
 
3331
#ifdef __WXMSW__
 
3332
        doc->SetUndoCollection ( false );
 
3333
        doc->SetUndoCollection ( true );
 
3334
#endif
 
3335
 
 
3336
        int id, type;
 
3337
        id = event.GetId();
 
3338
        type = (id == ID_STYLE) ? ID_TYPE_STYLE : ID_TYPE_SPELL;
 
3339
                
 
3340
 
 
3341
        std::string rawBufferUtf8;
 
3342
        getRawText ( doc, rawBufferUtf8 );
 
3343
        bool success = true; // always true for now: well-formedness not req'd 
 
3344
 
 
3345
        auto_ptr<StyleDialog> sd ( new StyleDialog (
 
3346
                                       this,
 
3347
                                       wxICON ( appicon ),
 
3348
                                       rawBufferUtf8,
 
3349
                                       doc->getShortFileName(),
 
3350
                                       ruleSetDir,
 
3351
                                       filterDir,
 
3352
                                       browserCommand,
 
3353
                                                   ( type == ID_TYPE_SPELL ) ? dictionaryPreset : ruleSetPreset,
 
3354
                                       filterPreset,
 
3355
 #ifdef __WXMSW__
 
3356
                                   aspellDataPath,
 
3357
                                   aspellDictPath,
 
3358
 #endif
 
3359
                                                       type,
 
3360
                                       ( success ) ? false : true,
 
3361
                                       stylePosition,
 
3362
                                       styleSize ) );
 
3363
 
 
3364
        if ( sd->ShowModal() == wxID_OK )
 
3365
        {
 
3366
                std::string bufferUtf8 = sd->getEditedString();
 
3367
                if ( bufferUtf8.empty() )
 
3368
                        messagePane ( _ ( "Edited document empty" ), CONST_STOP );
 
3369
                else
 
3370
                        doc->SetTextRaw ( bufferUtf8.c_str() );
 
3371
        }
 
3372
        
 
3373
        // update presets if report has been created (even if followed by cancel)
 
3374
        if (type == ID_TYPE_STYLE)
 
3375
        {
 
3376
                ruleSetPreset = sd->getRuleSetPreset();
 
3377
                filterPreset = sd->getFilterPreset();
 
3378
        }
 
3379
        else
 
3380
                dictionaryPreset = sd->getRuleSetPreset();
 
3381
                
 
3382
#ifdef __WXMSW__
 
3383
        stylePosition = sd->getPosition();
 
3384
        styleSize = sd->getSize();
 
3385
#endif
 
3386
}
 
3387
 
 
3388
void MyFrame::OnPreviousDocument ( wxCommandEvent& WXUNUSED ( event ) )
 
3389
{
 
3390
        if ( !getActiveDocument() )
 
3391
                return;
 
3392
 
 
3393
        statusProgress ( wxEmptyString );
 
3394
        closePane();
 
3395
 
 
3396
        int currentSelection = mainBook->GetSelection();
 
3397
        if ( currentSelection < 1 )
 
3398
                return;
 
3399
        mainBook->SetSelection ( --currentSelection );
 
3400
        XmlDoc *doc = getActiveDocument();
 
3401
        if ( doc )
 
3402
                doc->SetFocus();
 
3403
}
 
3404
 
 
3405
void MyFrame::OnNextDocument ( wxCommandEvent& WXUNUSED ( event ) )
 
3406
{
 
3407
        if ( !getActiveDocument() )
 
3408
                return;
 
3409
 
 
3410
        statusProgress ( wxEmptyString );
 
3411
        closePane();
 
3412
 
 
3413
        int currentSelection = mainBook->GetSelection();
 
3414
        int maxSelection = mainBook->GetPageCount();
 
3415
        if ( currentSelection >= ( maxSelection - 1 ) )
 
3416
                return;
 
3417
        mainBook->SetSelection ( ++currentSelection );
 
3418
        XmlDoc *doc = getActiveDocument();
 
3419
        if ( doc )
 
3420
                doc->SetFocus();
 
3421
}
 
3422
 
 
3423
void MyFrame::OnSave ( wxCommandEvent& event )
 
3424
{
 
3425
        save();
 
3426
}
 
3427
 
 
3428
void MyFrame::save()
 
3429
{
 
3430
        XmlDoc *doc;
 
3431
        if ( ( doc = getActiveDocument() ) == NULL )
 
3432
                return;
 
3433
 
 
3434
        wxString fileName;
 
3435
        if ( ( fileName = doc->getFullFileName() ) == _T ( "" ) )
 
3436
        {
 
3437
                wxCommandEvent event;
 
3438
                OnSaveAs ( event );
 
3439
                return;
 
3440
        }
 
3441
 
 
3442
        if ( !saveFile ( doc, fileName, true ) )
 
3443
                ; // handle messages in saveFile
 
3444
}
 
3445
 
 
3446
void MyFrame::OnReload ( wxCommandEvent& event )
 
3447
{
 
3448
        reloadTab();
 
3449
}
 
3450
 
 
3451
void MyFrame::reloadTab()
 
3452
{
 
3453
        XmlDoc *doc;
 
3454
        if ( ( doc = getActiveDocument() ) == NULL )
 
3455
                return;
 
3456
        wxString fileName = doc->getFullFileName();
 
3457
 
 
3458
        if ( closeActiveDocument() )
 
3459
                openFile ( fileName );
 
3460
}
 
3461
 
 
3462
void MyFrame::OnSaveAs ( wxCommandEvent& event )
 
3463
{