desktop/src/CUI_Evolution.cc

   1 ///
   2 /// \file       CUI_Evolution.cc
   3 ///             ConfigUI derived class to configure the Evolution App
   4 ///
   5
   6 /*
   7     Copyright (C) 2009-2013, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "CUI_Evolution.h"
  23 #include "EvoSources.h"
  24 #include "EvoCfgDlg.h"
  25 #include "EvoDefaultDlg.h"
  26 #include "os22.h"                       // only for the dynamic_cast
  27 #include "windowids.h"
  28 #include <wx/wx.h>
  29 #include <wx/process.h>
  30 #include "wxi18n.h"
  31
  32 namespace AppConfig {
  33
  34 namespace {
  35         class ExecCallback : public wxProcess
  36         {
  37         public:
  38                 wxDialog *m_waitdlg;
  39                 int m_pid;
  40                 int m_status;
  41
  42                 ExecCallback(wxDialog *dlg)
  43                         : m_waitdlg(dlg)
  44                         , m_pid(0)
  45                         , m_status(0)
  46                 {
  47                 }
  48
  49                 virtual void OnTerminate(int pid, int status)
  50                 {
  51                         m_pid = pid;
  52                         m_status = status;
  53
  54                         if( m_waitdlg ) {
  55                                 // close the dialog and let it delete us
  56                                 m_waitdlg->EndModal(wxID_OK);
  57                         }
  58                         else {
  59                                 // our parent doesn't exist, delete ourselves
  60                                 delete this;
  61                         }
  62                 }
  63         };
  64
  65         class WaitDialog : public wxDialog
  66         {
  67                 DECLARE_EVENT_TABLE()
  68         public:
  69                 WaitDialog(wxWindow *parent, const wxString &msg,
  70                         const wxString &title)
  71                         : wxDialog(parent, wxID_ANY, title)
  72                 {
  73                         wxBoxSizer *top = new wxBoxSizer(wxVERTICAL);
  74                         top->Add( new wxStaticText(this, wxID_ANY, msg),
  75                                 0, wxALL | wxALIGN_LEFT, 10);
  76                         top->Add( new wxButton(this, wxID_CANCEL,
  77                                                 _W("Stop waiting")),
  78                                 0, wxALL | wxALIGN_RIGHT, 5);
  79                         SetSizer(top);
  80                         top->SetSizeHints(this);
  81                         top->Layout();
  82
  83                         SetEscapeId(wxID_CANCEL);
  84                 }
  85
  86                 void OnButton(wxCommandEvent &event)
  87                 {
  88                         EndModal(wxID_CANCEL);
  89                 }
  90         };
  91
  92         BEGIN_EVENT_TABLE(WaitDialog, wxDialog)
  93                 EVT_BUTTON      (wxID_CANCEL, WaitDialog::OnButton)
  94         END_EVENT_TABLE()
  95 } // namespace
  96
  97 //////////////////////////////////////////////////////////////////////////////
  98 // Static utility functions
  99
 100 long Evolution::ForceShutdown()
 101 {
 102         ExecHelper shutdown(NULL);
 103         shutdown.Run(NULL, _C("Evolution shutdown"), _T("evolution --force-shutdown"));
 104         shutdown.WaitForChild();
 105         return shutdown.GetChildExitCode();
 106 }
 107
 108
 109 //////////////////////////////////////////////////////////////////////////////
 110 // EvolutionPtrBase class
 111
 112 EvolutionPtrBase::EvolutionPtrBase()
 113         : m_evolution(0)
 114 {
 115 }
 116
 117 void EvolutionPtrBase::AcquirePlugin(plugin_ptr old_plugin)
 118 {
 119         // create our plugin config
 120         m_evolution = dynamic_cast<OpenSync::Config::Evolution*> (old_plugin.get());
 121         if( m_evolution ) {
 122                 m_evolution = m_evolution->Clone();
 123         }
 124         else {
 125                 m_evolution = new OpenSync::Config::Evolution;
 126         }
 127         m_container.reset( m_evolution );
 128 }
 129
 130 OpenSync::Config::Evolution* EvolutionPtrBase::GetEvolutionPtr()
 131 {
 132         return m_evolution;
 133 }
 134
 135 void EvolutionPtrBase::Clear()
 136 {
 137         m_container.reset();
 138         m_evolution = 0;
 139 }
 140
 141 ConfigUI::plugin_ptr EvolutionPtrBase::GetPlugin()
 142 {
 143         m_evolution = 0;
 144         return m_container;
 145 }
 146
 147 //////////////////////////////////////////////////////////////////////////////
 148 // Evolution config UI class
 149
 150 Evolution::Evolution()
 151         : m_parent(0)
 152 {
 153 }
 154
 155 bool Evolution::InitialRun()
 156 {
 157         wxString msg = _W(
 158                 "Unable to automatically detect Evolution's configuration.\n"
 159                 "You need to run Evolution, and manually click each of the\n"
 160                 "section buttons:\n"
 161                 "\n"
 162                 "      Mail, Contacts, Calendars, Memos, and Tasks\n"
 163                 "\n"
 164                 "Then quit Evolution to continue configuration.\n"
 165                 "\n"
 166                 "Would you like to start Evolution now?\n");
 167
 168         int choice = wxMessageBox(msg, _W("Evolution Config"),
 169                 wxYES_NO | wxICON_QUESTION, m_parent);
 170
 171         if( choice == wxNO )
 172                 return false;
 173
 174         ForceShutdown();
 175
 176         // start Evolution, and wait for it to exit, showing a waiting
 177         // message to the user
 178         WaitDialog waitdlg(m_parent, _W("Waiting for Evolution to exit..."),
 179                 _W("Evolution Running"));
 180
 181         ExecCallback *callback = new ExecCallback(&waitdlg);
 182
 183         const wxChar *start_argv[] = {
 184                 _T("evolution"),
 185                 NULL
 186         };
 187         long ret = wxExecute((wxChar**)start_argv, wxEXEC_ASYNC, callback);
 188         if( ret == 0 ) {
 189                 delete callback;
 190                 wxMessageBox(_W("Failed to run evolution. Please make sure it is installed and in your PATH."), _W("Evolution Config"), wxOK | wxICON_ERROR, m_parent);
 191                 return false;
 192         }
 193
 194         if( waitdlg.ShowModal() == wxID_CANCEL ) {
 195                 // user aborted, so ExecCallback will be left
 196                 // waiting, and waitdlg will go out of scope, so
 197                 // reset the callback's pointer
 198                 callback->m_waitdlg = 0;
 199                 return false;   // user aborted
 200         }
 201         else {
 202                 // if we don't get wxID_CANCEL, then the callback
 203                 // closed us, and we can delete it
 204                 if( callback->m_status ) {
 205                         // error status code
 206                         wxMessageBox(_W("Failed to run evolution. Please make sure it is installed and in your PATH."), _W("Evolution Config"), wxOK | wxICON_ERROR, m_parent);
 207                         delete callback;
 208                         return false;
 209                 }
 210                 else {
 211                         delete callback;
 212                 }
 213         }
 214
 215         // so far so good...
 216         return true;
 217 }
 218
 219 std::string Evolution::AppName() const
 220 {
 221         return OpenSync::Config::Evolution::AppName();
 222 }
 223
 224 bool Evolution::Configure(wxWindow *parent, plugin_ptr old_plugin)
 225 {
 226         m_parent = parent;
 227
 228         AcquirePlugin(old_plugin);
 229
 230         // auto detect first
 231         EvoSources srcs;
 232
 233         // if no sources are found at all, and if Evolution is in the path
 234         //      do InitialRun and then auto detect again
 235         if( srcs.IsEmpty() ) {
 236                 if( !InitialRun() ) {
 237                         // impossible to do initial run, so fail here
 238                         Clear();
 239                         return false;
 240                 }
 241                 srcs.Detect();
 242         }
 243
 244         // we now have an auto detect (EvoSources) to work with
 245         // if minimum three paths are available, and if no list has
 246         //      more than 1 item, then just default to those settings
 247         //      and notify the user... in the notification, allow
 248         //      the user to "Manual Cfg..." button
 249         bool manual = false;
 250         if( srcs.IsDefaultable() ) {
 251                 EvoDefaultDlg dlg(m_parent);
 252                 if( dlg.ShowModal() == Dialog_EvoDefault_ManualConfigButton ) {
 253                         manual = true;
 254                 }
 255         }
 256
 257         // otherwise, if default settings are not possible, then
 258         //      load the path config dialog without notification
 259         if( !srcs.IsDefaultable() || manual ) {
 260                 EvoCfgDlg cfgdlg(m_parent, *GetEvolutionPtr(), srcs);
 261                 if( cfgdlg.ShowModal() == wxID_OK ) {
 262                         cfgdlg.SetPaths(*GetEvolutionPtr());
 263                 }
 264                 else {
 265                         Clear();
 266                         return false;
 267                 }
 268         }
 269         else {
 270                 // it's defaultable!  use default paths
 271                 GetEvolutionPtr()->SetAddressPath(srcs.GetAddressBook().size() ?
 272                         srcs.GetAddressBook()[0].m_SourcePath : "");
 273                 GetEvolutionPtr()->SetCalendarPath(srcs.GetEvents().size() ?
 274                         srcs.GetEvents()[0].m_SourcePath : "");
 275                 GetEvolutionPtr()->SetTasksPath(srcs.GetTasks().size() ?
 276                         srcs.GetTasks()[0].m_SourcePath : "");
 277                 GetEvolutionPtr()->SetMemosPath(srcs.GetMemos().size() ?
 278                         srcs.GetMemos()[0].m_SourcePath : "");
 279         }
 280
 281         // success!
 282         return true;
 283 }
 284
 285 bool Evolution::RunApp(wxWindow *parent)
 286 {
 287         return Run(parent, AppName(), _T("evolution"));
 288 }
 289
 290 void Evolution::PreSyncAppInit()
 291 {
 292         ForceShutdown();
 293 }
 294
 295 bool Evolution::ZapData(wxWindow *parent,
 296                         plugin_ptr plugin,
 297                         OpenSync::API *engine)
 298 {
 299         m_parent = parent;
 300
 301         // extract OpenSync::Config::Evolution from plugin
 302         // this *can* throw an exception if the wrong plugin is
 303         // passed in, but we want this... such an exception would
 304         // represent a bug in the app, not a runtime error
 305 //      OpenSync::Config::Evolution &evo =
 306 //              dynamic_cast<OpenSync::Config::Evolution&>(*plugin);
 307
 308         if( IsAppRunning() ) {
 309                 wxMessageBox(_W("Evolution already running."),
 310                         _W("Oops..."), wxOK | wxICON_INFORMATION,
 311                         m_parent);
 312                 return false;
 313         }
 314
 315         // tell the user what to do
 316         wxString msg;
 317         if( dynamic_cast<OpenSync::OpenSync22*>(engine) ) {
 318                 msg = _W(
 319                 "Starting Evolution.  Delete all contacts and/or calendar "
 320                 "entries manually, depending on your sync configuration.");
 321         }
 322         else {
 323                 msg = _W(
 324                 "Starting Evolution.  Delete all objects (contacts, calendar, "
 325                 "memos, and tasks, depending on your sync configuration)."
 326                 );
 327         }
 328         int choice = wxMessageBox(msg, _W("Starting Evolution"),
 329                         wxOK | wxCANCEL | wxICON_QUESTION, m_parent);
 330         if( choice != wxOK )
 331                 return false;
 332
 333         RunApp(parent);
 334
 335         // wait for app to finish... this is kinda lame, but
 336         // we don't want other Zaps to happen before this is finished
 337         while( IsAppRunning() )
 338                 wxMilliSleep(500);
 339
 340         return true;
 341 }
 342
 343
 344 //////////////////////////////////////////////////////////////////////////////
 345 // Evolution3 class
 346
 347 Evolution3::Evolution3()
 348         : m_evolution3(0)
 349 {
 350 }
 351
 352 void Evolution3::AcquirePlugin(plugin_ptr old_plugin)
 353 {
 354         // create our plugin config
 355         m_evolution3 = dynamic_cast<OpenSync::Config::Evolution3*> (old_plugin.get());
 356         if( m_evolution3 ) {
 357                 m_evolution3 = m_evolution3->Clone();
 358         }
 359         else {
 360                 m_evolution3 = new OpenSync::Config::Evolution3;
 361         }
 362         m_container.reset( m_evolution3 );
 363 }
 364
 365 OpenSync::Config::Evolution* Evolution3::GetEvolutionPtr()
 366 {
 367         return m_evolution3;
 368 }
 369
 370 void Evolution3::Clear()
 371 {
 372         m_container.reset();
 373         m_evolution3 = 0;
 374 }
 375
 376 ConfigUI::plugin_ptr Evolution3::GetPlugin()
 377 {
 378         m_evolution3 = 0;
 379         return m_container;
 380 }
 381
 382
 383 } // namespace AppConfig
 384