ui.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Distributed under the MIT/X11 software license, see the accompanying
   3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #include "headers.h"
   6 #ifdef _MSC_VER
   7 #include <crtdbg.h>
   8 #endif
   9
  10
  11
  12 DEFINE_EVENT_TYPE(wxEVT_UITHREADCALL)
  13
  14 CMainFrame* pframeMain = NULL;
  15 CMyTaskBarIcon* ptaskbaricon = NULL;
  16 bool fClosedToTray = false;
  17 wxLocale g_locale;
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27 //////////////////////////////////////////////////////////////////////////////
  28 //
  29 // Util
  30 //
  31
  32 void HandleCtrlA(wxKeyEvent& event)
  33 {
  34     // Ctrl-a select all
  35     event.Skip();
  36     wxTextCtrl* textCtrl = (wxTextCtrl*)event.GetEventObject();
  37     if (event.GetModifiers() == wxMOD_CONTROL && event.GetKeyCode() == 'A')
  38         textCtrl->SetSelection(-1, -1);
  39 }
  40
  41 bool Is24HourTime()
  42 {
  43     //char pszHourFormat[256];
  44     //pszHourFormat[0] = '\0';
  45     //GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ITIME, pszHourFormat, 256);
  46     //return (pszHourFormat[0] != '0');
  47     return true;
  48 }
  49
  50 string DateStr(int64 nTime)
  51 {
  52     // Can only be used safely here in the UI
  53     return (string)wxDateTime((time_t)nTime).FormatDate();
  54 }
  55
  56 string DateTimeStr(int64 nTime)
  57 {
  58     // Can only be used safely here in the UI
  59     wxDateTime datetime((time_t)nTime);
  60     if (Is24HourTime())
  61         return (string)datetime.Format("%x %H:%M");
  62     else
  63         return (string)datetime.Format("%x ") + itostr((datetime.GetHour() + 11) % 12 + 1) + (string)datetime.Format(":%M %p");
  64 }
  65
  66 wxString GetItemText(wxListCtrl* listCtrl, int nIndex, int nColumn)
  67 {
  68     // Helper to simplify access to listctrl
  69     wxListItem item;
  70     item.m_itemId = nIndex;
  71     item.m_col = nColumn;
  72     item.m_mask = wxLIST_MASK_TEXT;
  73     if (!listCtrl->GetItem(item))
  74         return "";
  75     return item.GetText();
  76 }
  77
  78 int InsertLine(wxListCtrl* listCtrl, const wxString& str0, const wxString& str1)
  79 {
  80     int nIndex = listCtrl->InsertItem(listCtrl->GetItemCount(), str0);
  81     listCtrl->SetItem(nIndex, 1, str1);
  82     return nIndex;
  83 }
  84
  85 int InsertLine(wxListCtrl* listCtrl, const wxString& str0, const wxString& str1, const wxString& str2, const wxString& str3, const wxString& str4)
  86 {
  87     int nIndex = listCtrl->InsertItem(listCtrl->GetItemCount(), str0);
  88     listCtrl->SetItem(nIndex, 1, str1);
  89     listCtrl->SetItem(nIndex, 2, str2);
  90     listCtrl->SetItem(nIndex, 3, str3);
  91     listCtrl->SetItem(nIndex, 4, str4);
  92     return nIndex;
  93 }
  94
  95 int InsertLine(wxListCtrl* listCtrl, void* pdata, const wxString& str0, const wxString& str1, const wxString& str2, const wxString& str3, const wxString& str4)
  96 {
  97     int nIndex = listCtrl->InsertItem(listCtrl->GetItemCount(), str0);
  98     listCtrl->SetItemPtrData(nIndex, (wxUIntPtr)pdata);
  99     listCtrl->SetItem(nIndex, 1, str1);
 100     listCtrl->SetItem(nIndex, 2, str2);
 101     listCtrl->SetItem(nIndex, 3, str3);
 102     listCtrl->SetItem(nIndex, 4, str4);
 103     return nIndex;
 104 }
 105
 106 void SetItemTextColour(wxListCtrl* listCtrl, int nIndex, const wxColour& colour)
 107 {
 108     // Repaint on Windows is more flickery if the colour has ever been set,
 109     // so don't want to set it unless it's different.  Default colour has
 110     // alpha 0 transparent, so our colours don't match using operator==.
 111     wxColour c1 = listCtrl->GetItemTextColour(nIndex);
 112     if (!c1.IsOk())
 113         c1 = wxColour(0,0,0);
 114     if (colour.Red() != c1.Red() || colour.Green() != c1.Green() || colour.Blue() != c1.Blue())
 115         listCtrl->SetItemTextColour(nIndex, colour);
 116 }
 117
 118 void SetSelection(wxListCtrl* listCtrl, int nIndex)
 119 {
 120     int nSize = listCtrl->GetItemCount();
 121     long nState = (wxLIST_STATE_SELECTED|wxLIST_STATE_FOCUSED);
 122     for (int i = 0; i < nSize; i++)
 123         listCtrl->SetItemState(i, (i == nIndex ? nState : 0), nState);
 124 }
 125
 126 int GetSelection(wxListCtrl* listCtrl)
 127 {
 128     int nSize = listCtrl->GetItemCount();
 129     for (int i = 0; i < nSize; i++)
 130         if (listCtrl->GetItemState(i, wxLIST_STATE_FOCUSED))
 131             return i;
 132     return -1;
 133 }
 134
 135 string HtmlEscape(const char* psz, bool fMultiLine=false)
 136 {
 137     int len = 0;
 138     for (const char* p = psz; *p; p++)
 139     {
 140              if (*p == '<') len += 4;
 141         else if (*p == '>') len += 4;
 142         else if (*p == '&') len += 5;
 143         else if (*p == '"') len += 6;
 144         else if (*p == ' ' && p > psz && p[-1] == ' ' && p[1] == ' ') len += 6;
 145         else if (*p == '\n' && fMultiLine) len += 5;
 146         else
 147             len++;
 148     }
 149     string str;
 150     str.reserve(len);
 151     for (const char* p = psz; *p; p++)
 152     {
 153              if (*p == '<') str += "&lt;";
 154         else if (*p == '>') str += "&gt;";
 155         else if (*p == '&') str += "&amp;";
 156         else if (*p == '"') str += "&quot;";
 157         else if (*p == ' ' && p > psz && p[-1] == ' ' && p[1] == ' ') str += "&nbsp;";
 158         else if (*p == '\n' && fMultiLine) str += "<br>\n";
 159         else
 160             str += *p;
 161     }
 162     return str;
 163 }
 164
 165 string HtmlEscape(const string& str, bool fMultiLine=false)
 166 {
 167     return HtmlEscape(str.c_str(), fMultiLine);
 168 }
 169
 170 void CalledMessageBox(const string& message, const string& caption, int style, wxWindow* parent, int x, int y, int* pnRet, bool* pfDone)
 171 {
 172     *pnRet = wxMessageBox(message, caption, style, parent, x, y);
 173     *pfDone = true;
 174 }
 175
 176 int ThreadSafeMessageBox(const string& message, const string& caption, int style, wxWindow* parent, int x, int y)
 177 {
 178 #ifdef __WXMSW__
 179     return wxMessageBox(message, caption, style, parent, x, y);
 180 #else
 181     if (wxThread::IsMain() || fDaemon)
 182     {
 183         return wxMessageBox(message, caption, style, parent, x, y);
 184     }
 185     else
 186     {
 187         int nRet = 0;
 188         bool fDone = false;
 189         UIThreadCall(bind(CalledMessageBox, message, caption, style, parent, x, y, &nRet, &fDone));
 190         while (!fDone)
 191             Sleep(100);
 192         return nRet;
 193     }
 194 #endif
 195 }
 196
 197 bool ThreadSafeAskFee(int64 nFeeRequired, const string& strCaption, wxWindow* parent)
 198 {
 199     if (nFeeRequired < CENT || nFeeRequired <= nTransactionFee || fDaemon)
 200         return true;
 201     string strMessage = strprintf(
 202         _("This transaction is over the size limit.  You can still send it for a fee of %s, "
 203           "which goes to the nodes that process your transaction and helps to support the network.  "
 204           "Do you want to pay the fee?"),
 205         FormatMoney(nFeeRequired).c_str());
 206     return (ThreadSafeMessageBox(strMessage, strCaption, wxYES_NO, parent) == wxYES);
 207 }
 208
 209 void CalledSetStatusBar(const string& strText, int nField)
 210 {
 211     if (nField == 0 && GetWarnings("statusbar") != "")
 212         return;
 213     if (pframeMain && pframeMain->m_statusBar)
 214         pframeMain->m_statusBar->SetStatusText(strText, nField);
 215 }
 216
 217 void SetDefaultReceivingAddress(const string& strAddress)
 218 {
 219     // Update main window address and database
 220     if (pframeMain == NULL)
 221         return;
 222     if (strAddress != pframeMain->m_textCtrlAddress->GetValue())
 223     {
 224         uint160 hash160;
 225         if (!AddressToHash160(strAddress, hash160))
 226             return;
 227         if (!mapPubKeys.count(hash160))
 228             return;
 229         CWalletDB().WriteDefaultKey(mapPubKeys[hash160]);
 230         pframeMain->m_textCtrlAddress->SetValue(strAddress);
 231     }
 232 }
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243 //////////////////////////////////////////////////////////////////////////////
 244 //
 245 // CMainFrame
 246 //
 247
 248 CMainFrame::CMainFrame(wxWindow* parent) : CMainFrameBase(parent)
 249 {
 250     Connect(wxEVT_UITHREADCALL, wxCommandEventHandler(CMainFrame::OnUIThreadCall), NULL, this);
 251
 252     // Set initially selected page
 253     wxNotebookEvent event;
 254     event.SetSelection(0);
 255     OnNotebookPageChanged(event);
 256     m_notebook->ChangeSelection(0);
 257
 258     // Init
 259     fRefreshListCtrl = false;
 260     fRefreshListCtrlRunning = false;
 261     fOnSetFocusAddress = false;
 262     fRefresh = false;
 263     m_choiceFilter->SetSelection(0);
 264     double dResize = 1.0;
 265 #ifdef __WXMSW__
 266     SetIcon(wxICON(bitcoin));
 267 #else
 268     SetIcon(bitcoin80_xpm);
 269     SetBackgroundColour(m_toolBar->GetBackgroundColour());
 270     wxFont fontTmp = m_staticText41->GetFont();
 271     fontTmp.SetFamily(wxFONTFAMILY_TELETYPE);
 272     m_staticTextBalance->SetFont(fontTmp);
 273     m_staticTextBalance->SetSize(140, 17);
 274     // resize to fit ubuntu's huge default font
 275     dResize = 1.22;
 276     SetSize(dResize * GetSize().GetWidth(), 1.15 * GetSize().GetHeight());
 277 #endif
 278     m_staticTextBalance->SetLabel(FormatMoney(GetBalance()) + "  ");
 279     m_listCtrl->SetFocus();
 280     ptaskbaricon = new CMyTaskBarIcon();
 281 #ifdef __WXMAC_OSX__
 282     // Mac automatically moves wxID_EXIT, wxID_PREFERENCES and wxID_ABOUT
 283     // to their standard places, leaving these menus empty.
 284     GetMenuBar()->Remove(2); // remove Help menu
 285     GetMenuBar()->Remove(0); // remove File menu
 286 #endif
 287
 288     // Init column headers
 289     int nDateWidth = DateTimeStr(1229413914).size() * 6 + 8;
 290     if (!strstr(DateTimeStr(1229413914).c_str(), "2008"))
 291         nDateWidth += 12;
 292 #ifdef __WXMAC_OSX__
 293     nDateWidth += 5;
 294     dResize -= 0.01;
 295 #endif
 296     wxListCtrl* pplistCtrl[] = {m_listCtrlAll, m_listCtrlSentReceived, m_listCtrlSent, m_listCtrlReceived};
 297     foreach(wxListCtrl* p, pplistCtrl)
 298     {
 299         p->InsertColumn(0, "",               wxLIST_FORMAT_LEFT,  dResize * 0);
 300         p->InsertColumn(1, "",               wxLIST_FORMAT_LEFT,  dResize * 0);
 301         p->InsertColumn(2, _("Status"),      wxLIST_FORMAT_LEFT,  dResize * 112);
 302         p->InsertColumn(3, _("Date"),        wxLIST_FORMAT_LEFT,  dResize * nDateWidth);
 303         p->InsertColumn(4, _("Description"), wxLIST_FORMAT_LEFT,  dResize * 409 - nDateWidth);
 304         p->InsertColumn(5, _("Debit"),       wxLIST_FORMAT_RIGHT, dResize * 79);
 305         p->InsertColumn(6, _("Credit"),      wxLIST_FORMAT_RIGHT, dResize * 79);
 306     }
 307
 308     // Init status bar
 309     int pnWidths[3] = { -100, 88, 300 };
 310 #ifndef __WXMSW__
 311     pnWidths[1] = pnWidths[1] * 1.1 * dResize;
 312     pnWidths[2] = pnWidths[2] * 1.1 * dResize;
 313 #endif
 314     m_statusBar->SetFieldsCount(3, pnWidths);
 315
 316     // Fill your address text box
 317     vector<unsigned char> vchPubKey;
 318     if (CWalletDB("r").ReadDefaultKey(vchPubKey))
 319         m_textCtrlAddress->SetValue(PubKeyToAddress(vchPubKey));
 320
 321     // Fill listctrl with wallet transactions
 322     RefreshListCtrl();
 323 }
 324
 325 CMainFrame::~CMainFrame()
 326 {
 327     pframeMain = NULL;
 328     delete ptaskbaricon;
 329     ptaskbaricon = NULL;
 330 }
 331
 332 void CMainFrame::OnNotebookPageChanged(wxNotebookEvent& event)
 333 {
 334     event.Skip();
 335     nPage = event.GetSelection();
 336     if (nPage == ALL)
 337     {
 338         m_listCtrl = m_listCtrlAll;
 339         fShowGenerated = true;
 340         fShowSent = true;
 341         fShowReceived = true;
 342     }
 343     else if (nPage == SENTRECEIVED)
 344     {
 345         m_listCtrl = m_listCtrlSentReceived;
 346         fShowGenerated = false;
 347         fShowSent = true;
 348         fShowReceived = true;
 349     }
 350     else if (nPage == SENT)
 351     {
 352         m_listCtrl = m_listCtrlSent;
 353         fShowGenerated = false;
 354         fShowSent = true;
 355         fShowReceived = false;
 356     }
 357     else if (nPage == RECEIVED)
 358     {
 359         m_listCtrl = m_listCtrlReceived;
 360         fShowGenerated = false;
 361         fShowSent = false;
 362         fShowReceived = true;
 363     }
 364     RefreshListCtrl();
 365     m_listCtrl->SetFocus();
 366 }
 367
 368 void CMainFrame::OnClose(wxCloseEvent& event)
 369 {
 370     if (fMinimizeOnClose && event.CanVeto() && !IsIconized())
 371     {
 372         // Divert close to minimize
 373         event.Veto();
 374         fClosedToTray = true;
 375         Iconize(true);
 376     }
 377     else
 378     {
 379         Destroy();
 380         CreateThread(Shutdown, NULL);
 381     }
 382 }
 383
 384 void CMainFrame::OnIconize(wxIconizeEvent& event)
 385 {
 386     event.Skip();
 387     // Hide the task bar button when minimized.
 388     // Event is sent when the frame is minimized or restored.
 389     // wxWidgets 2.8.9 doesn't have IsIconized() so there's no way
 390     // to get rid of the deprecated warning.  Just ignore it.
 391     if (!event.Iconized())
 392         fClosedToTray = false;
 393 #if defined(__WXGTK__) || defined(__WXMAC_OSX__)
 394     if (GetBoolArg("-minimizetotray")) {
 395 #endif
 396     // The tray icon sometimes disappears on ubuntu karmic
 397     // Hiding the taskbar button doesn't work cleanly on ubuntu lucid
 398     // Reports of CPU peg on 64-bit linux
 399     if (fMinimizeToTray && event.Iconized())
 400         fClosedToTray = true;
 401     Show(!fClosedToTray);
 402     ptaskbaricon->Show(fMinimizeToTray || fClosedToTray);
 403 #if defined(__WXGTK__) || defined(__WXMAC_OSX__)
 404     }
 405 #endif
 406 }
 407
 408 void CMainFrame::OnMouseEvents(wxMouseEvent& event)
 409 {
 410     event.Skip();
 411     RandAddSeed();
 412     RAND_add(&event.m_x, sizeof(event.m_x), 0.25);
 413     RAND_add(&event.m_y, sizeof(event.m_y), 0.25);
 414 }
 415
 416 void CMainFrame::OnListColBeginDrag(wxListEvent& event)
 417 {
 418     // Hidden columns not resizeable
 419     if (event.GetColumn() <= 1 && !fDebug)
 420         event.Veto();
 421     else
 422         event.Skip();
 423 }
 424
 425 int CMainFrame::GetSortIndex(const string& strSort)
 426 {
 427 #ifdef __WXMSW__
 428     return 0;
 429 #else
 430     // The wx generic listctrl implementation used on GTK doesn't sort,
 431     // so we have to do it ourselves.  Remember, we sort in reverse order.
 432     // In the wx generic implementation, they store the list of items
 433     // in a vector, so indexed lookups are fast, but inserts are slower
 434     // the closer they are to the top.
 435     int low = 0;
 436     int high = m_listCtrl->GetItemCount();
 437     while (low < high)
 438     {
 439         int mid = low + ((high - low) / 2);
 440         if (strSort.compare(m_listCtrl->GetItemText(mid).c_str()) >= 0)
 441             high = mid;
 442         else
 443             low = mid + 1;
 444     }
 445     return low;
 446 #endif
 447 }
 448
 449 void CMainFrame::InsertLine(bool fNew, int nIndex, uint256 hashKey, string strSort, const wxColour& colour, const wxString& str2, const wxString& str3, const wxString& str4, const wxString& str5, const wxString& str6)
 450 {
 451     strSort = " " + strSort;       // leading space to workaround wx2.9.0 ubuntu 9.10 bug
 452     long nData = *(long*)&hashKey; //  where first char of hidden column is displayed
 453
 454     // Find item
 455     if (!fNew && nIndex == -1)
 456     {
 457         string strHash = " " + hashKey.ToString();
 458         while ((nIndex = m_listCtrl->FindItem(nIndex, nData)) != -1)
 459             if (GetItemText(m_listCtrl, nIndex, 1) == strHash)
 460                 break;
 461     }
 462
 463     // fNew is for blind insert, only use if you're sure it's new
 464     if (fNew || nIndex == -1)
 465     {
 466         nIndex = m_listCtrl->InsertItem(GetSortIndex(strSort), strSort);
 467     }
 468     else
 469     {
 470         // If sort key changed, must delete and reinsert to make it relocate
 471         if (GetItemText(m_listCtrl, nIndex, 0) != strSort)
 472         {
 473             m_listCtrl->DeleteItem(nIndex);
 474             nIndex = m_listCtrl->InsertItem(GetSortIndex(strSort), strSort);
 475         }
 476     }
 477
 478     m_listCtrl->SetItem(nIndex, 1, " " + hashKey.ToString());
 479     m_listCtrl->SetItem(nIndex, 2, str2);
 480     m_listCtrl->SetItem(nIndex, 3, str3);
 481     m_listCtrl->SetItem(nIndex, 4, str4);
 482     m_listCtrl->SetItem(nIndex, 5, str5);
 483     m_listCtrl->SetItem(nIndex, 6, str6);
 484     m_listCtrl->SetItemData(nIndex, nData);
 485     SetItemTextColour(m_listCtrl, nIndex, colour);
 486 }
 487
 488 bool CMainFrame::DeleteLine(uint256 hashKey)
 489 {
 490     long nData = *(long*)&hashKey;
 491
 492     // Find item
 493     int nIndex = -1;
 494     string strHash = " " + hashKey.ToString();
 495     while ((nIndex = m_listCtrl->FindItem(nIndex, nData)) != -1)
 496         if (GetItemText(m_listCtrl, nIndex, 1) == strHash)
 497             break;
 498
 499     if (nIndex != -1)
 500         m_listCtrl->DeleteItem(nIndex);
 501
 502     return nIndex != -1;
 503 }
 504
 505 string FormatTxStatus(const CWalletTx& wtx)
 506 {
 507     // Status
 508     if (!wtx.IsFinal())
 509     {
 510         if (wtx.nLockTime < 500000000)
 511             return strprintf(_("Open for %d blocks"), nBestHeight - wtx.nLockTime);
 512         else
 513             return strprintf(_("Open until %s"), DateTimeStr(wtx.nLockTime).c_str());
 514     }
 515     else
 516     {
 517         int nDepth = wtx.GetDepthInMainChain();
 518         if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
 519             return strprintf(_("%d/offline?"), nDepth);
 520         else if (nDepth < 6)
 521             return strprintf(_("%d/unconfirmed"), nDepth);
 522         else
 523             return strprintf(_("%d confirmations"), nDepth);
 524     }
 525 }
 526
 527 string SingleLine(const string& strIn)
 528 {
 529     string strOut;
 530     bool fOneSpace = false;
 531     foreach(unsigned char c, strIn)
 532     {
 533         if (isspace(c))
 534         {
 535             fOneSpace = true;
 536         }
 537         else if (c > ' ')
 538         {
 539             if (fOneSpace && !strOut.empty())
 540                 strOut += ' ';
 541             strOut += c;
 542             fOneSpace = false;
 543         }
 544     }
 545     return strOut;
 546 }
 547
 548 bool CMainFrame::InsertTransaction(const CWalletTx& wtx, bool fNew, int nIndex)
 549 {
 550     int64 nTime = wtx.nTimeDisplayed = wtx.GetTxTime();
 551     int64 nCredit = wtx.GetCredit(true);
 552     int64 nDebit = wtx.GetDebit();
 553     int64 nNet = nCredit - nDebit;
 554     uint256 hash = wtx.GetHash();
 555     string strStatus = FormatTxStatus(wtx);
 556     bool fConfirmed = wtx.fConfirmedDisplayed = wtx.IsConfirmed();
 557     wxColour colour = (fConfirmed ? wxColour(0,0,0) : wxColour(128,128,128));
 558     map<string, string> mapValue = wtx.mapValue;
 559     wtx.nLinesDisplayed = 1;
 560     nListViewUpdated++;
 561
 562     // Filter
 563     if (wtx.IsCoinBase())
 564     {
 565         // Don't show generated coin until confirmed by at least one block after it
 566         // so we don't get the user's hopes up until it looks like it's probably accepted.
 567         //
 568         // It is not an error when generated blocks are not accepted.  By design,
 569         // some percentage of blocks, like 10% or more, will end up not accepted.
 570         // This is the normal mechanism by which the network copes with latency.
 571         //
 572         // We display regular transactions right away before any confirmation
 573         // because they can always get into some block eventually.  Generated coins
 574         // are special because if their block is not accepted, they are not valid.
 575         //
 576         if (wtx.GetDepthInMainChain() < 2)
 577         {
 578             wtx.nLinesDisplayed = 0;
 579             return false;
 580         }
 581
 582         if (!fShowGenerated)
 583             return false;
 584     }
 585
 586     // Find the block the tx is in
 587     CBlockIndex* pindex = NULL;
 588     map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(wtx.hashBlock);
 589     if (mi != mapBlockIndex.end())
 590         pindex = (*mi).second;
 591
 592     // Sort order, unrecorded transactions sort to the top
 593     string strSort = strprintf("%010d-%01d-%010u",
 594         (pindex ? pindex->nHeight : INT_MAX),
 595         (wtx.IsCoinBase() ? 1 : 0),
 596         wtx.nTimeReceived);
 597
 598     // Insert line
 599     if (nNet > 0 || wtx.IsCoinBase())
 600     {
 601         //
 602         // Credit
 603         //
 604         string strDescription;
 605         if (wtx.IsCoinBase())
 606         {
 607             // Generated
 608             strDescription = _("Generated");
 609             if (nCredit == 0)
 610             {
 611                 int64 nUnmatured = 0;
 612                 foreach(const CTxOut& txout, wtx.vout)
 613                     nUnmatured += txout.GetCredit();
 614                 if (wtx.IsInMainChain())
 615                 {
 616                     strDescription = strprintf(_("Generated (%s matures in %d more blocks)"), FormatMoney(nUnmatured).c_str(), wtx.GetBlocksToMaturity());
 617
 618                     // Check if the block was requested by anyone
 619                     if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
 620                         strDescription = _("Generated - Warning: This block was not received by any other nodes and will probably not be accepted!");
 621                 }
 622                 else
 623                 {
 624                     strDescription = _("Generated (not accepted)");
 625                 }
 626             }
 627         }
 628         else if (!mapValue["from"].empty() || !mapValue["message"].empty())
 629         {
 630             // Received by IP connection
 631             if (!fShowReceived)
 632                 return false;
 633             if (!mapValue["from"].empty())
 634                 strDescription += _("From: ") + mapValue["from"];
 635             if (!mapValue["message"].empty())
 636             {
 637                 if (!strDescription.empty())
 638                     strDescription += " - ";
 639                 strDescription += mapValue["message"];
 640             }
 641         }
 642         else
 643         {
 644             // Received by Bitcoin Address
 645             if (!fShowReceived)
 646                 return false;
 647             foreach(const CTxOut& txout, wtx.vout)
 648             {
 649                 if (txout.IsMine())
 650                 {
 651                     vector<unsigned char> vchPubKey;
 652                     if (ExtractPubKey(txout.scriptPubKey, true, vchPubKey))
 653                     {
 654                         CRITICAL_BLOCK(cs_mapAddressBook)
 655                         {
 656                             //strDescription += _("Received payment to ");
 657                             //strDescription += _("Received with address ");
 658                             strDescription += _("Received with: ");
 659                             string strAddress = PubKeyToAddress(vchPubKey);
 660                             map<string, string>::iterator mi = mapAddressBook.find(strAddress);
 661                             if (mi != mapAddressBook.end() && !(*mi).second.empty())
 662                             {
 663                                 string strLabel = (*mi).second;
 664                                 strDescription += strAddress.substr(0,12) + "... ";
 665                                 strDescription += "(" + strLabel + ")";
 666                             }
 667                             else
 668                                 strDescription += strAddress;
 669                         }
 670                     }
 671                     break;
 672                 }
 673             }
 674         }
 675
 676         string strCredit = FormatMoney(nNet, true);
 677         if (!fConfirmed)
 678             strCredit = "[" + strCredit + "]";
 679
 680         InsertLine(fNew, nIndex, hash, strSort, colour,
 681                    strStatus,
 682                    nTime ? DateTimeStr(nTime) : "",
 683                    SingleLine(strDescription),
 684                    "",
 685                    strCredit);
 686     }
 687     else
 688     {
 689         bool fAllFromMe = true;
 690         foreach(const CTxIn& txin, wtx.vin)
 691             fAllFromMe = fAllFromMe && txin.IsMine();
 692
 693         bool fAllToMe = true;
 694         foreach(const CTxOut& txout, wtx.vout)
 695             fAllToMe = fAllToMe && txout.IsMine();
 696
 697         if (fAllFromMe && fAllToMe)
 698         {
 699             // Payment to self
 700             int64 nChange = wtx.GetChange();
 701             InsertLine(fNew, nIndex, hash, strSort, colour,
 702                        strStatus,
 703                        nTime ? DateTimeStr(nTime) : "",
 704                        _("Payment to yourself"),
 705                        FormatMoney(-(nDebit - nChange), true),
 706                        FormatMoney(nCredit - nChange, true));
 707         }
 708         else if (fAllFromMe)
 709         {
 710             //
 711             // Debit
 712             //
 713             if (!fShowSent)
 714                 return false;
 715
 716             int64 nTxFee = nDebit - wtx.GetValueOut();
 717             wtx.nLinesDisplayed = 0;
 718             for (int nOut = 0; nOut < wtx.vout.size(); nOut++)
 719             {
 720                 const CTxOut& txout = wtx.vout[nOut];
 721                 if (txout.IsMine())
 722                     continue;
 723
 724                 string strAddress;
 725                 if (!mapValue["to"].empty())
 726                 {
 727                     // Sent to IP
 728                     strAddress = mapValue["to"];
 729                 }
 730                 else
 731                 {
 732                     // Sent to Bitcoin Address
 733                     uint160 hash160;
 734                     if (ExtractHash160(txout.scriptPubKey, hash160))
 735                         strAddress = Hash160ToAddress(hash160);
 736                 }
 737
 738                 string strDescription = _("To: ");
 739                 CRITICAL_BLOCK(cs_mapAddressBook)
 740                     if (mapAddressBook.count(strAddress) && !mapAddressBook[strAddress].empty())
 741                         strDescription += mapAddressBook[strAddress] + " ";
 742                 strDescription += strAddress;
 743                 if (!mapValue["message"].empty())
 744                 {
 745                     if (!strDescription.empty())
 746                         strDescription += " - ";
 747                     strDescription += mapValue["message"];
 748                 }
 749                 else if (!mapValue["comment"].empty())
 750                 {
 751                     if (!strDescription.empty())
 752                         strDescription += " - ";
 753                     strDescription += mapValue["comment"];
 754                 }
 755
 756                 int64 nValue = txout.nValue;
 757                 if (nTxFee > 0)
 758                 {
 759                     nValue += nTxFee;
 760                     nTxFee = 0;
 761                 }
 762
 763                 InsertLine(fNew, nIndex, hash, strprintf("%s-%d", strSort.c_str(), nOut), colour,
 764                            strStatus,
 765                            nTime ? DateTimeStr(nTime) : "",
 766                            SingleLine(strDescription),
 767                            FormatMoney(-nValue, true),
 768                            "");
 769                 nIndex = -1;
 770                 wtx.nLinesDisplayed++;
 771             }
 772         }
 773         else
 774         {
 775             //
 776             // Mixed debit transaction, can't break down payees
 777             //
 778             bool fAllMine = true;
 779             foreach(const CTxOut& txout, wtx.vout)
 780                 fAllMine = fAllMine && txout.IsMine();
 781             foreach(const CTxIn& txin, wtx.vin)
 782                 fAllMine = fAllMine && txin.IsMine();
 783
 784             InsertLine(fNew, nIndex, hash, strSort, colour,
 785                        strStatus,
 786                        nTime ? DateTimeStr(nTime) : "",
 787                        "",
 788                        FormatMoney(nNet, true),
 789                        "");
 790         }
 791     }
 792
 793     return true;
 794 }
 795
 796 void CMainFrame::RefreshListCtrl()
 797 {
 798     fRefreshListCtrl = true;
 799     ::wxWakeUpIdle();
 800 }
 801
 802 void CMainFrame::OnIdle(wxIdleEvent& event)
 803 {
 804     if (fRefreshListCtrl)
 805     {
 806         // Collect list of wallet transactions and sort newest first
 807         bool fEntered = false;
 808         vector<pair<unsigned int, uint256> > vSorted;
 809         TRY_CRITICAL_BLOCK(cs_mapWallet)
 810         {
 811             printf("RefreshListCtrl starting\n");
 812             fEntered = true;
 813             fRefreshListCtrl = false;
 814             vWalletUpdated.clear();
 815
 816             // Do the newest transactions first
 817             vSorted.reserve(mapWallet.size());
 818             for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 819             {
 820                 const CWalletTx& wtx = (*it).second;
 821                 unsigned int nTime = UINT_MAX - wtx.GetTxTime();
 822                 vSorted.push_back(make_pair(nTime, (*it).first));
 823             }
 824             m_listCtrl->DeleteAllItems();
 825         }
 826         if (!fEntered)
 827             return;
 828
 829         sort(vSorted.begin(), vSorted.end());
 830
 831         // Fill list control
 832         for (int i = 0; i < vSorted.size();)
 833         {
 834             if (fShutdown)
 835                 return;
 836             bool fEntered = false;
 837             TRY_CRITICAL_BLOCK(cs_mapWallet)
 838             {
 839                 fEntered = true;
 840                 uint256& hash = vSorted[i++].second;
 841                 map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
 842                 if (mi != mapWallet.end())
 843                     InsertTransaction((*mi).second, true);
 844             }
 845             if (!fEntered || i == 100 || i % 500 == 0)
 846                 wxYield();
 847         }
 848
 849         printf("RefreshListCtrl done\n");
 850
 851         // Update transaction total display
 852         MainFrameRepaint();
 853     }
 854     else
 855     {
 856         // Check for time updates
 857         static int64 nLastTime;
 858         if (GetTime() > nLastTime + 30)
 859         {
 860             TRY_CRITICAL_BLOCK(cs_mapWallet)
 861             {
 862                 nLastTime = GetTime();
 863                 for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 864                 {
 865                     CWalletTx& wtx = (*it).second;
 866                     if (wtx.nTimeDisplayed && wtx.nTimeDisplayed != wtx.GetTxTime())
 867                         InsertTransaction(wtx, false);
 868                 }
 869             }
 870         }
 871     }
 872 }
 873
 874 void CMainFrame::RefreshStatusColumn()
 875 {
 876     static int nLastTop;
 877     static CBlockIndex* pindexLastBest;
 878     static unsigned int nLastRefreshed;
 879
 880     int nTop = max((int)m_listCtrl->GetTopItem(), 0);
 881     if (nTop == nLastTop && pindexLastBest == pindexBest)
 882         return;
 883
 884     TRY_CRITICAL_BLOCK(cs_mapWallet)
 885     {
 886         int nStart = nTop;
 887         int nEnd = min(nStart + 100, m_listCtrl->GetItemCount());
 888
 889         if (pindexLastBest == pindexBest && nLastRefreshed == nListViewUpdated)
 890         {
 891             // If no updates, only need to do the part that moved onto the screen
 892             if (nStart >= nLastTop && nStart < nLastTop + 100)
 893                 nStart = nLastTop + 100;
 894             if (nEnd >= nLastTop && nEnd < nLastTop + 100)
 895                 nEnd = nLastTop;
 896         }
 897         nLastTop = nTop;
 898         pindexLastBest = pindexBest;
 899         nLastRefreshed = nListViewUpdated;
 900
 901         for (int nIndex = nStart; nIndex < min(nEnd, m_listCtrl->GetItemCount()); nIndex++)
 902         {
 903             uint256 hash((string)GetItemText(m_listCtrl, nIndex, 1));
 904             map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
 905             if (mi == mapWallet.end())
 906             {
 907                 printf("CMainFrame::RefreshStatusColumn() : tx not found in mapWallet\n");
 908                 continue;
 909             }
 910             CWalletTx& wtx = (*mi).second;
 911             if (wtx.IsCoinBase() ||
 912                 wtx.GetTxTime() != wtx.nTimeDisplayed ||
 913                 wtx.IsConfirmed() != wtx.fConfirmedDisplayed)
 914             {
 915                 if (!InsertTransaction(wtx, false, nIndex))
 916                     m_listCtrl->DeleteItem(nIndex--);
 917             }
 918             else
 919             {
 920                 m_listCtrl->SetItem(nIndex, 2, FormatTxStatus(wtx));
 921             }
 922         }
 923     }
 924 }
 925
 926 void CMainFrame::OnPaint(wxPaintEvent& event)
 927 {
 928     event.Skip();
 929     if (fRefresh)
 930     {
 931         fRefresh = false;
 932         Refresh();
 933     }
 934 }
 935
 936
 937 unsigned int nNeedRepaint = 0;
 938 unsigned int nLastRepaint = 0;
 939 int64 nLastRepaintTime = 0;
 940 int64 nRepaintInterval = 500;
 941
 942 void ThreadDelayedRepaint(void* parg)
 943 {
 944     while (!fShutdown)
 945     {
 946         if (nLastRepaint != nNeedRepaint && GetTimeMillis() - nLastRepaintTime >= nRepaintInterval)
 947         {
 948             nLastRepaint = nNeedRepaint;
 949             if (pframeMain)
 950             {
 951                 printf("DelayedRepaint\n");
 952                 wxPaintEvent event;
 953                 pframeMain->fRefresh = true;
 954                 pframeMain->GetEventHandler()->AddPendingEvent(event);
 955             }
 956         }
 957         Sleep(nRepaintInterval);
 958     }
 959 }
 960
 961 void MainFrameRepaint()
 962 {
 963     // This is called by network code that shouldn't access pframeMain
 964     // directly because it could still be running after the UI is closed.
 965     if (pframeMain)
 966     {
 967         // Don't repaint too often
 968         static int64 nLastRepaintRequest;
 969         if (GetTimeMillis() - nLastRepaintRequest < 100)
 970         {
 971             nNeedRepaint++;
 972             return;
 973         }
 974         nLastRepaintRequest = GetTimeMillis();
 975
 976         printf("MainFrameRepaint\n");
 977         wxPaintEvent event;
 978         pframeMain->fRefresh = true;
 979         pframeMain->GetEventHandler()->AddPendingEvent(event);
 980     }
 981 }
 982
 983 void CMainFrame::OnPaintListCtrl(wxPaintEvent& event)
 984 {
 985     // Skip lets the listctrl do the paint, we're just hooking the message
 986     event.Skip();
 987
 988     if (ptaskbaricon)
 989         ptaskbaricon->UpdateTooltip();
 990
 991     //
 992     // Slower stuff
 993     //
 994     static int nTransactionCount;
 995     bool fPaintedBalance = false;
 996     if (GetTimeMillis() - nLastRepaintTime >= nRepaintInterval)
 997     {
 998         nLastRepaint = nNeedRepaint;
 999         nLastRepaintTime = GetTimeMillis();
1000
1001         // Update listctrl contents
1002         if (!vWalletUpdated.empty())
1003         {
1004             TRY_CRITICAL_BLOCK(cs_mapWallet)
1005             {
1006                 string strTop;
1007                 if (m_listCtrl->GetItemCount())
1008                     strTop = (string)m_listCtrl->GetItemText(0);
1009                 foreach(uint256 hash, vWalletUpdated)
1010                 {
1011                     map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
1012                     if (mi != mapWallet.end())
1013                         InsertTransaction((*mi).second, false);
1014                 }
1015                 vWalletUpdated.clear();
1016                 if (m_listCtrl->GetItemCount() && strTop != (string)m_listCtrl->GetItemText(0))
1017                     m_listCtrl->ScrollList(0, INT_MIN/2);
1018             }
1019         }
1020
1021         // Balance total
1022         TRY_CRITICAL_BLOCK(cs_mapWallet)
1023         {
1024             fPaintedBalance = true;
1025             m_staticTextBalance->SetLabel(FormatMoney(GetBalance()) + "  ");
1026
1027             // Count hidden and multi-line transactions
1028             nTransactionCount = 0;
1029             for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1030             {
1031                 CWalletTx& wtx = (*it).second;
1032                 nTransactionCount += wtx.nLinesDisplayed;
1033             }
1034         }
1035     }
1036     if (!vWalletUpdated.empty() || !fPaintedBalance)
1037         nNeedRepaint++;
1038
1039     // Update status column of visible items only
1040     RefreshStatusColumn();
1041
1042     // Update status bar
1043     static string strPrevWarning;
1044     string strWarning = GetWarnings("statusbar");
1045     if (strWarning != "")
1046         m_statusBar->SetStatusText(string("    ") + _(strWarning), 0);
1047     else if (strPrevWarning != "")
1048         m_statusBar->SetStatusText("", 0);
1049     strPrevWarning = strWarning;
1050
1051     string strGen = "";
1052     if (fGenerateBitcoins)
1053         strGen = _("    Generating");
1054     if (fGenerateBitcoins && vNodes.empty())
1055         strGen = _("(not connected)");
1056     m_statusBar->SetStatusText(strGen, 1);
1057
1058     string strStatus = strprintf(_("     %d connections     %d blocks     %d transactions"), vNodes.size(), nBestHeight, nTransactionCount);
1059     m_statusBar->SetStatusText(strStatus, 2);
1060
1061     // Update receiving address
1062     string strDefaultAddress = PubKeyToAddress(vchDefaultKey);
1063     if (m_textCtrlAddress->GetValue() != strDefaultAddress)
1064         m_textCtrlAddress->SetValue(strDefaultAddress);
1065 }
1066
1067
1068 void UIThreadCall(boost::function0<void> fn)
1069 {
1070     // Call this with a function object created with bind.
1071     // bind needs all parameters to match the function's expected types
1072     // and all default parameters specified.  Some examples:
1073     //  UIThreadCall(bind(wxBell));
1074     //  UIThreadCall(bind(wxMessageBox, wxT("Message"), wxT("Title"), wxOK, (wxWindow*)NULL, -1, -1));
1075     //  UIThreadCall(bind(&CMainFrame::OnMenuHelpAbout, pframeMain, event));
1076     if (pframeMain)
1077     {
1078         wxCommandEvent event(wxEVT_UITHREADCALL);
1079         event.SetClientData((void*)new boost::function0<void>(fn));
1080         pframeMain->GetEventHandler()->AddPendingEvent(event);
1081     }
1082 }
1083
1084 void CMainFrame::OnUIThreadCall(wxCommandEvent& event)
1085 {
1086     boost::function0<void>* pfn = (boost::function0<void>*)event.GetClientData();
1087     (*pfn)();
1088     delete pfn;
1089 }
1090
1091 void CMainFrame::OnMenuFileExit(wxCommandEvent& event)
1092 {
1093     // File->Exit
1094     Close(true);
1095 }
1096
1097 void CMainFrame::OnUpdateUIOptionsGenerate(wxUpdateUIEvent& event)
1098 {
1099     event.Check(fGenerateBitcoins);
1100 }
1101
1102 void CMainFrame::OnMenuOptionsChangeYourAddress(wxCommandEvent& event)
1103 {
1104     // Options->Your Receiving Addresses
1105     CAddressBookDialog dialog(this, "", CAddressBookDialog::RECEIVING, false);
1106     if (!dialog.ShowModal())
1107         return;
1108 }
1109
1110 void CMainFrame::OnMenuOptionsOptions(wxCommandEvent& event)
1111 {
1112     // Options->Options
1113     COptionsDialog dialog(this);
1114     dialog.ShowModal();
1115 }
1116
1117 void CMainFrame::OnMenuHelpAbout(wxCommandEvent& event)
1118 {
1119     // Help->About
1120     CAboutDialog dialog(this);
1121     dialog.ShowModal();
1122 }
1123
1124 void CMainFrame::OnButtonSend(wxCommandEvent& event)
1125 {
1126     // Toolbar: Send
1127     CSendDialog dialog(this);
1128     dialog.ShowModal();
1129 }
1130
1131 void CMainFrame::OnButtonAddressBook(wxCommandEvent& event)
1132 {
1133     // Toolbar: Address Book
1134     CAddressBookDialog dialogAddr(this, "", CAddressBookDialog::SENDING, false);
1135     if (dialogAddr.ShowModal() == 2)
1136     {
1137         // Send
1138         CSendDialog dialogSend(this, dialogAddr.GetSelectedAddress());
1139         dialogSend.ShowModal();
1140     }
1141 }
1142
1143 void CMainFrame::OnSetFocusAddress(wxFocusEvent& event)
1144 {
1145     // Automatically select-all when entering window
1146     event.Skip();
1147     m_textCtrlAddress->SetSelection(-1, -1);
1148     fOnSetFocusAddress = true;
1149 }
1150
1151 void CMainFrame::OnMouseEventsAddress(wxMouseEvent& event)
1152 {
1153     event.Skip();
1154     if (fOnSetFocusAddress)
1155         m_textCtrlAddress->SetSelection(-1, -1);
1156     fOnSetFocusAddress = false;
1157 }
1158
1159 void CMainFrame::OnButtonNew(wxCommandEvent& event)
1160 {
1161     // Ask name
1162     CGetTextFromUserDialog dialog(this,
1163         _("New Receiving Address"),
1164         _("You should use a new address for each payment you receive.\n\nLabel"),
1165         "");
1166     if (!dialog.ShowModal())
1167         return;
1168     string strName = dialog.GetValue();
1169
1170     // Generate new key
1171     string strAddress = PubKeyToAddress(GetKeyFromKeyPool());
1172
1173     // Save
1174     SetAddressBookName(strAddress, strName);
1175     SetDefaultReceivingAddress(strAddress);
1176 }
1177
1178 void CMainFrame::OnButtonCopy(wxCommandEvent& event)
1179 {
1180     // Copy address box to clipboard
1181     if (wxTheClipboard->Open())
1182     {
1183         wxTheClipboard->SetData(new wxTextDataObject(m_textCtrlAddress->GetValue()));
1184         wxTheClipboard->Close();
1185     }
1186 }
1187
1188 void CMainFrame::OnListItemActivated(wxListEvent& event)
1189 {
1190     uint256 hash((string)GetItemText(m_listCtrl, event.GetIndex(), 1));
1191     CWalletTx wtx;
1192     CRITICAL_BLOCK(cs_mapWallet)
1193     {
1194         map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
1195         if (mi == mapWallet.end())
1196         {
1197             printf("CMainFrame::OnListItemActivated() : tx not found in mapWallet\n");
1198             return;
1199         }
1200         wtx = (*mi).second;
1201     }
1202     CTxDetailsDialog dialog(this, wtx);
1203     dialog.ShowModal();
1204     //CTxDetailsDialog* pdialog = new CTxDetailsDialog(this, wtx);
1205     //pdialog->Show();
1206 }
1207
1208
1209
1210
1211
1212
1213 //////////////////////////////////////////////////////////////////////////////
1214 //
1215 // CTxDetailsDialog
1216 //
1217
1218 CTxDetailsDialog::CTxDetailsDialog(wxWindow* parent, CWalletTx wtx) : CTxDetailsDialogBase(parent)
1219 {
1220     CRITICAL_BLOCK(cs_mapAddressBook)
1221     {
1222         string strHTML;
1223         strHTML.reserve(4000);
1224         strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
1225
1226         int64 nTime = wtx.GetTxTime();
1227         int64 nCredit = wtx.GetCredit();
1228         int64 nDebit = wtx.GetDebit();
1229         int64 nNet = nCredit - nDebit;
1230
1231
1232
1233         strHTML += _("<b>Status:</b> ") + FormatTxStatus(wtx);
1234         int nRequests = wtx.GetRequestCount();
1235         if (nRequests != -1)
1236         {
1237             if (nRequests == 0)
1238                 strHTML += _(", has not been successfully broadcast yet");
1239             else if (nRequests == 1)
1240                 strHTML += strprintf(_(", broadcast through %d node"), nRequests);
1241             else
1242                 strHTML += strprintf(_(", broadcast through %d nodes"), nRequests);
1243         }
1244         strHTML += "<br>";
1245
1246         strHTML += _("<b>Date:</b> ") + (nTime ? DateTimeStr(nTime) : "") + "<br>";
1247
1248
1249         //
1250         // From
1251         //
1252         if (wtx.IsCoinBase())
1253         {
1254             strHTML += _("<b>Source:</b> Generated<br>");
1255         }
1256         else if (!wtx.mapValue["from"].empty())
1257         {
1258             // Online transaction
1259             if (!wtx.mapValue["from"].empty())
1260                 strHTML += _("<b>From:</b> ") + HtmlEscape(wtx.mapValue["from"]) + "<br>";
1261         }
1262         else
1263         {
1264             // Offline transaction
1265             if (nNet > 0)
1266             {
1267                 // Credit
1268                 foreach(const CTxOut& txout, wtx.vout)
1269                 {
1270                     if (txout.IsMine())
1271                     {
1272                         vector<unsigned char> vchPubKey;
1273                         if (ExtractPubKey(txout.scriptPubKey, true, vchPubKey))
1274                         {
1275                             string strAddress = PubKeyToAddress(vchPubKey);
1276                             if (mapAddressBook.count(strAddress))
1277                             {
1278                                 strHTML += string() + _("<b>From:</b> ") + _("unknown") + "<br>";
1279                                 strHTML += _("<b>To:</b> ");
1280                                 strHTML += HtmlEscape(strAddress);
1281                                 if (!mapAddressBook[strAddress].empty())
1282                                     strHTML += _(" (yours, label: ") + mapAddressBook[strAddress] + ")";
1283                                 else
1284                                     strHTML += _(" (yours)");
1285                                 strHTML += "<br>";
1286                             }
1287                         }
1288                         break;
1289                     }
1290                 }
1291             }
1292         }
1293
1294
1295         //
1296         // To
1297         //
1298         string strAddress;
1299         if (!wtx.mapValue["to"].empty())
1300         {
1301             // Online transaction
1302             strAddress = wtx.mapValue["to"];
1303             strHTML += _("<b>To:</b> ");
1304             if (mapAddressBook.count(strAddress) && !mapAddressBook[strAddress].empty())
1305                 strHTML += mapAddressBook[strAddress] + " ";
1306             strHTML += HtmlEscape(strAddress) + "<br>";
1307         }
1308
1309
1310         //
1311         // Amount
1312         //
1313         if (wtx.IsCoinBase() && nCredit == 0)
1314         {
1315             //
1316             // Coinbase
1317             //
1318             int64 nUnmatured = 0;
1319             foreach(const CTxOut& txout, wtx.vout)
1320                 nUnmatured += txout.GetCredit();
1321             strHTML += _("<b>Credit:</b> ");
1322             if (wtx.IsInMainChain())
1323                 strHTML += strprintf(_("(%s matures in %d more blocks)"), FormatMoney(nUnmatured).c_str(), wtx.GetBlocksToMaturity());
1324             else
1325                 strHTML += _("(not accepted)");
1326             strHTML += "<br>";
1327         }
1328         else if (nNet > 0)
1329         {
1330             //
1331             // Credit
1332             //
1333             strHTML += _("<b>Credit:</b> ") + FormatMoney(nNet) + "<br>";
1334         }
1335         else
1336         {
1337             bool fAllFromMe = true;
1338             foreach(const CTxIn& txin, wtx.vin)
1339                 fAllFromMe = fAllFromMe && txin.IsMine();
1340
1341             bool fAllToMe = true;
1342             foreach(const CTxOut& txout, wtx.vout)
1343                 fAllToMe = fAllToMe && txout.IsMine();
1344
1345             if (fAllFromMe)
1346             {
1347                 //
1348                 // Debit
1349                 //
1350                 foreach(const CTxOut& txout, wtx.vout)
1351                 {
1352                     if (txout.IsMine())
1353                         continue;
1354
1355                     if (wtx.mapValue["to"].empty())
1356                     {
1357                         // Offline transaction
1358                         uint160 hash160;
1359                         if (ExtractHash160(txout.scriptPubKey, hash160))
1360                         {
1361                             string strAddress = Hash160ToAddress(hash160);
1362                             strHTML += _("<b>To:</b> ");
1363                             if (mapAddressBook.count(strAddress) && !mapAddressBook[strAddress].empty())
1364                                 strHTML += mapAddressBook[strAddress] + " ";
1365                             strHTML += strAddress;
1366                             strHTML += "<br>";
1367                         }
1368                     }
1369
1370                     strHTML += _("<b>Debit:</b> ") + FormatMoney(-txout.nValue) + "<br>";
1371                 }
1372
1373                 if (fAllToMe)
1374                 {
1375                     // Payment to self
1376                     int64 nChange = wtx.GetChange();
1377                     int64 nValue = nCredit - nChange;
1378                     strHTML += _("<b>Debit:</b> ") + FormatMoney(-nValue) + "<br>";
1379                     strHTML += _("<b>Credit:</b> ") + FormatMoney(nValue) + "<br>";
1380                 }
1381
1382                 int64 nTxFee = nDebit - wtx.GetValueOut();
1383                 if (nTxFee > 0)
1384                     strHTML += _("<b>Transaction fee:</b> ") + FormatMoney(-nTxFee) + "<br>";
1385             }
1386             else
1387             {
1388                 //
1389                 // Mixed debit transaction
1390                 //
1391                 foreach(const CTxIn& txin, wtx.vin)
1392                     if (txin.IsMine())
1393                         strHTML += _("<b>Debit:</b> ") + FormatMoney(-txin.GetDebit()) + "<br>";
1394                 foreach(const CTxOut& txout, wtx.vout)
1395                     if (txout.IsMine())
1396                         strHTML += _("<b>Credit:</b> ") + FormatMoney(txout.GetCredit()) + "<br>";
1397             }
1398         }
1399
1400         strHTML += _("<b>Net amount:</b> ") + FormatMoney(nNet, true) + "<br>";
1401
1402
1403         //
1404         // Message
1405         //
1406         if (!wtx.mapValue["message"].empty())
1407             strHTML += string() + "<br><b>" + _("Message:") + "</b><br>" + HtmlEscape(wtx.mapValue["message"], true) + "<br>";
1408         if (!wtx.mapValue["comment"].empty())
1409             strHTML += string() + "<br><b>" + _("Comment:") + "</b><br>" + HtmlEscape(wtx.mapValue["comment"], true) + "<br>";
1410
1411         if (wtx.IsCoinBase())
1412             strHTML += string() + "<br>" + _("Generated coins must wait 120 blocks before they can be spent.  When you generated this block, it was broadcast to the network to be added to the block chain.  If it fails to get into the chain, it will change to \"not accepted\" and not be spendable.  This may occasionally happen if another node generates a block within a few seconds of yours.") + "<br>";
1413
1414
1415         //
1416         // Debug view
1417         //
1418         if (fDebug)
1419         {
1420             strHTML += "<hr><br>debug print<br><br>";
1421             foreach(const CTxIn& txin, wtx.vin)
1422                 if (txin.IsMine())
1423                     strHTML += "<b>Debit:</b> " + FormatMoney(-txin.GetDebit()) + "<br>";
1424             foreach(const CTxOut& txout, wtx.vout)
1425                 if (txout.IsMine())
1426                     strHTML += "<b>Credit:</b> " + FormatMoney(txout.GetCredit()) + "<br>";
1427
1428             strHTML += "<br><b>Transaction:</b><br>";
1429             strHTML += HtmlEscape(wtx.ToString(), true);
1430
1431             strHTML += "<br><b>Inputs:</b><br>";
1432             CRITICAL_BLOCK(cs_mapWallet)
1433             {
1434                 foreach(const CTxIn& txin, wtx.vin)
1435                 {
1436                     COutPoint prevout = txin.prevout;
1437                     map<uint256, CWalletTx>::iterator mi = mapWallet.find(prevout.hash);
1438                     if (mi != mapWallet.end())
1439                     {
1440                         const CWalletTx& prev = (*mi).second;
1441                         if (prevout.n < prev.vout.size())
1442                         {
1443                             strHTML += HtmlEscape(prev.ToString(), true);
1444                             strHTML += " &nbsp;&nbsp; " + FormatTxStatus(prev) + ", ";
1445                             strHTML = strHTML + "IsMine=" + (prev.vout[prevout.n].IsMine() ? "true" : "false") + "<br>";
1446                         }
1447                     }
1448                 }
1449             }
1450         }
1451
1452
1453
1454         strHTML += "</font></html>";
1455         string(strHTML.begin(), strHTML.end()).swap(strHTML);
1456         m_htmlWin->SetPage(strHTML);
1457         m_buttonOK->SetFocus();
1458     }
1459 }
1460
1461 void CTxDetailsDialog::OnButtonOK(wxCommandEvent& event)
1462 {
1463     EndModal(false);
1464 }
1465
1466
1467
1468
1469
1470
1471 //////////////////////////////////////////////////////////////////////////////
1472 //
1473 // Startup folder
1474 //
1475
1476 #ifdef __WXMSW__
1477 string StartupShortcutPath()
1478 {
1479     return MyGetSpecialFolderPath(CSIDL_STARTUP, true) + "\\Bitcoin.lnk";
1480 }
1481
1482 bool GetStartOnSystemStartup()
1483 {
1484     return filesystem::exists(StartupShortcutPath().c_str());
1485 }
1486
1487 void SetStartOnSystemStartup(bool fAutoStart)
1488 {
1489     // If the shortcut exists already, remove it for updating
1490     remove(StartupShortcutPath().c_str());
1491
1492     if (fAutoStart)
1493     {
1494         CoInitialize(NULL);
1495
1496         // Get a pointer to the IShellLink interface.
1497         IShellLink* psl = NULL;
1498         HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL,
1499                                 CLSCTX_INPROC_SERVER, IID_IShellLink,
1500                                 reinterpret_cast<void**>(&psl));
1501
1502         if (SUCCEEDED(hres))
1503         {
1504             // Get the current executable path
1505             TCHAR pszExePath[MAX_PATH];
1506             GetModuleFileName(NULL, pszExePath, sizeof(pszExePath));
1507
1508             // Set the path to the shortcut target
1509             psl->SetPath(pszExePath);
1510             PathRemoveFileSpec(pszExePath);
1511             psl->SetWorkingDirectory(pszExePath);
1512             psl->SetShowCmd(SW_SHOWMINNOACTIVE);
1513
1514             // Query IShellLink for the IPersistFile interface for
1515             // saving the shortcut in persistent storage.
1516             IPersistFile* ppf = NULL;
1517             hres = psl->QueryInterface(IID_IPersistFile,
1518                                        reinterpret_cast<void**>(&ppf));
1519             if (SUCCEEDED(hres))
1520             {
1521                 WCHAR pwsz[MAX_PATH];
1522                 // Ensure that the string is ANSI.
1523                 MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().c_str(), -1, pwsz, MAX_PATH);
1524                 // Save the link by calling IPersistFile::Save.
1525                 hres = ppf->Save(pwsz, TRUE);
1526                 ppf->Release();
1527             }
1528             psl->Release();
1529         }
1530         CoUninitialize();
1531     }
1532 }
1533
1534 #elif defined(__WXGTK__)
1535
1536 // Follow the Desktop Application Autostart Spec:
1537 //  http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
1538
1539 boost::filesystem::path GetAutostartDir()
1540 {
1541     namespace fs = boost::filesystem;
1542
1543     char* pszConfigHome = getenv("XDG_CONFIG_HOME");
1544     if (pszConfigHome) return fs::path(pszConfigHome) / fs::path("autostart");
1545     char* pszHome = getenv("HOME");
1546     if (pszHome) return fs::path(pszHome) / fs::path(".config/autostart");
1547     return fs::path();
1548 }
1549
1550 boost::filesystem::path GetAutostartFilePath()
1551 {
1552     return GetAutostartDir() / boost::filesystem::path("bitcoin.desktop");
1553 }
1554
1555 bool GetStartOnSystemStartup()
1556 {
1557     boost::filesystem::ifstream optionFile(GetAutostartFilePath());
1558     if (!optionFile.good())
1559         return false;
1560     // Scan through file for "Hidden=true":
1561     string line;
1562     while (!optionFile.eof())
1563     {
1564         getline(optionFile, line);
1565         if (line.find("Hidden") != string::npos &&
1566             line.find("true") != string::npos)
1567             return false;
1568     }
1569     optionFile.close();
1570
1571     return true;
1572 }
1573
1574 void SetStartOnSystemStartup(bool fAutoStart)
1575 {
1576     if (!fAutoStart)
1577     {
1578         unlink(GetAutostartFilePath().native_file_string().c_str());
1579     }
1580     else
1581     {
1582         char pszExePath[MAX_PATH+1];
1583         memset(pszExePath, 0, sizeof(pszExePath));
1584         if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath)-1) == -1)
1585             return;
1586
1587         boost::filesystem::create_directories(GetAutostartDir());
1588
1589         boost::filesystem::ofstream optionFile(GetAutostartFilePath(), ios_base::out|ios_base::trunc);
1590         if (!optionFile.good())
1591         {
1592             wxMessageBox(_("Cannot write autostart/bitcoin.desktop file"), "Bitcoin");
1593             return;
1594         }
1595         // Write a bitcoin.desktop file to the autostart directory:
1596         optionFile << "[Desktop Entry]\n";
1597         optionFile << "Type=Application\n";
1598         optionFile << "Name=Bitcoin\n";
1599         optionFile << "Exec=" << pszExePath << "\n";
1600         optionFile << "Terminal=false\n";
1601         optionFile << "Hidden=false\n";
1602         optionFile.close();
1603     }
1604 }
1605 #else
1606
1607 // TODO: OSX startup stuff; see:
1608 // http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPSystemStartup/Articles/CustomLogin.html
1609
1610 bool GetStartOnSystemStartup() { return false; }
1611 void SetStartOnSystemStartup(bool fAutoStart) { }
1612
1613 #endif
1614
1615
1616
1617
1618
1619
1620 //////////////////////////////////////////////////////////////////////////////
1621 //
1622 // COptionsDialog
1623 //
1624
1625 COptionsDialog::COptionsDialog(wxWindow* parent) : COptionsDialogBase(parent)
1626 {
1627     // Set up list box of page choices
1628     m_listBox->Append(_("Main"));
1629     //m_listBox->Append(_("Test 2"));
1630     m_listBox->SetSelection(0);
1631     SelectPage(0);
1632 #ifndef __WXMSW__
1633     SetSize(1.0 * GetSize().GetWidth(), 1.2 * GetSize().GetHeight());
1634 #endif
1635 #if defined(__WXGTK__) || defined(__WXMAC_OSX__)
1636     m_checkBoxStartOnSystemStartup->SetLabel(_("&Start Bitcoin on window system startup"));
1637     if (!GetBoolArg("-minimizetotray"))
1638     {
1639         // Minimize to tray is just too buggy on Linux
1640         fMinimizeToTray = false;
1641         m_checkBoxMinimizeToTray->SetValue(false);
1642         m_checkBoxMinimizeToTray->Enable(false);
1643         m_checkBoxMinimizeOnClose->SetLabel(_("&Minimize on close"));
1644     }
1645 #endif
1646 #ifdef __WXMAC_OSX__
1647     m_checkBoxStartOnSystemStartup->Enable(false); // not implemented yet
1648 #endif
1649
1650     // Init values
1651     m_textCtrlTransactionFee->SetValue(FormatMoney(nTransactionFee));
1652     m_checkBoxStartOnSystemStartup->SetValue(fTmpStartOnSystemStartup = GetStartOnSystemStartup());
1653     m_checkBoxMinimizeToTray->SetValue(fMinimizeToTray);
1654     m_checkBoxMinimizeOnClose->SetValue(fMinimizeOnClose);
1655     if (fHaveUPnP)
1656         m_checkBoxUseUPnP->SetValue(fUseUPnP);
1657     else
1658         m_checkBoxUseUPnP->Enable(false);
1659     m_checkBoxUseProxy->SetValue(fUseProxy);
1660     m_textCtrlProxyIP->Enable(fUseProxy);
1661     m_textCtrlProxyPort->Enable(fUseProxy);
1662     m_staticTextProxyIP->Enable(fUseProxy);
1663     m_staticTextProxyPort->Enable(fUseProxy);
1664     m_textCtrlProxyIP->SetValue(addrProxy.ToStringIP());
1665     m_textCtrlProxyPort->SetValue(addrProxy.ToStringPort());
1666
1667     m_buttonOK->SetFocus();
1668 }
1669
1670 void COptionsDialog::SelectPage(int nPage)
1671 {
1672     m_panelMain->Show(nPage == 0);
1673     m_panelTest2->Show(nPage == 1);
1674
1675     m_scrolledWindow->Layout();
1676     m_scrolledWindow->SetScrollbars(0, 0, 0, 0, 0, 0);
1677 }
1678
1679 void COptionsDialog::OnListBox(wxCommandEvent& event)
1680 {
1681     SelectPage(event.GetSelection());
1682 }
1683
1684 void COptionsDialog::OnKillFocusTransactionFee(wxFocusEvent& event)
1685 {
1686     event.Skip();
1687     int64 nTmp = nTransactionFee;
1688     ParseMoney(m_textCtrlTransactionFee->GetValue(), nTmp);
1689     m_textCtrlTransactionFee->SetValue(FormatMoney(nTmp));
1690 }
1691
1692 void COptionsDialog::OnCheckBoxUseProxy(wxCommandEvent& event)
1693 {
1694     m_textCtrlProxyIP->Enable(event.IsChecked());
1695     m_textCtrlProxyPort->Enable(event.IsChecked());
1696     m_staticTextProxyIP->Enable(event.IsChecked());
1697     m_staticTextProxyPort->Enable(event.IsChecked());
1698 }
1699
1700 CAddress COptionsDialog::GetProxyAddr()
1701 {
1702     // Be careful about byte order, addr.ip and addr.port are big endian
1703     CAddress addr(m_textCtrlProxyIP->GetValue() + ":" + m_textCtrlProxyPort->GetValue());
1704     if (addr.ip == INADDR_NONE)
1705         addr.ip = addrProxy.ip;
1706     int nPort = atoi(m_textCtrlProxyPort->GetValue());
1707     addr.port = htons(nPort);
1708     if (nPort <= 0 || nPort > USHRT_MAX)
1709         addr.port = addrProxy.port;
1710     return addr;
1711 }
1712
1713 void COptionsDialog::OnKillFocusProxy(wxFocusEvent& event)
1714 {
1715     event.Skip();
1716     m_textCtrlProxyIP->SetValue(GetProxyAddr().ToStringIP());
1717     m_textCtrlProxyPort->SetValue(GetProxyAddr().ToStringPort());
1718 }
1719
1720
1721 void COptionsDialog::OnButtonOK(wxCommandEvent& event)
1722 {
1723     OnButtonApply(event);
1724     EndModal(false);
1725 }
1726
1727 void COptionsDialog::OnButtonCancel(wxCommandEvent& event)
1728 {
1729     EndModal(false);
1730 }
1731
1732 void COptionsDialog::OnButtonApply(wxCommandEvent& event)
1733 {
1734     CWalletDB walletdb;
1735
1736     int64 nPrevTransactionFee = nTransactionFee;
1737     if (ParseMoney(m_textCtrlTransactionFee->GetValue(), nTransactionFee) && nTransactionFee != nPrevTransactionFee)
1738         walletdb.WriteSetting("nTransactionFee", nTransactionFee);
1739
1740     if (fTmpStartOnSystemStartup != m_checkBoxStartOnSystemStartup->GetValue())
1741     {
1742         fTmpStartOnSystemStartup = m_checkBoxStartOnSystemStartup->GetValue();
1743         SetStartOnSystemStartup(fTmpStartOnSystemStartup);
1744     }
1745
1746     if (fMinimizeToTray != m_checkBoxMinimizeToTray->GetValue())
1747     {
1748         fMinimizeToTray = m_checkBoxMinimizeToTray->GetValue();
1749         walletdb.WriteSetting("fMinimizeToTray", fMinimizeToTray);
1750         ptaskbaricon->Show(fMinimizeToTray || fClosedToTray);
1751     }
1752
1753     if (fMinimizeOnClose != m_checkBoxMinimizeOnClose->GetValue())
1754     {
1755         fMinimizeOnClose = m_checkBoxMinimizeOnClose->GetValue();
1756         walletdb.WriteSetting("fMinimizeOnClose", fMinimizeOnClose);
1757     }
1758
1759     if (fHaveUPnP && fUseUPnP != m_checkBoxUseUPnP->GetValue())
1760     {
1761         fUseUPnP = m_checkBoxUseUPnP->GetValue();
1762         walletdb.WriteSetting("fUseUPnP", fUseUPnP);
1763         MapPort(fUseUPnP);
1764     }
1765
1766     fUseProxy = m_checkBoxUseProxy->GetValue();
1767     walletdb.WriteSetting("fUseProxy", fUseProxy);
1768
1769     addrProxy = GetProxyAddr();
1770     walletdb.WriteSetting("addrProxy", addrProxy);
1771 }
1772
1773
1774
1775
1776
1777
1778 //////////////////////////////////////////////////////////////////////////////
1779 //
1780 // CAboutDialog
1781 //
1782
1783 CAboutDialog::CAboutDialog(wxWindow* parent) : CAboutDialogBase(parent)
1784 {
1785     m_staticTextVersion->SetLabel(strprintf(_("version %s"), FormatFullVersion().c_str()));
1786
1787     // Change (c) into UTF-8 or ANSI copyright symbol
1788     wxString str = m_staticTextMain->GetLabel();
1789 #if wxUSE_UNICODE
1790     str.Replace("(c)", wxString::FromUTF8("\xC2\xA9"));
1791 #else
1792     str.Replace("(c)", "\xA9");
1793 #endif
1794     m_staticTextMain->SetLabel(str);
1795 #ifndef __WXMSW__
1796     // Resize on Linux to make the window fit the text.
1797     // The text was wrapped manually rather than using the Wrap setting because
1798     // the wrap would be too small on Linux and it can't be changed at this point.
1799     wxFont fontTmp = m_staticTextMain->GetFont();
1800     if (fontTmp.GetPointSize() > 8);
1801         fontTmp.SetPointSize(8);
1802     m_staticTextMain->SetFont(fontTmp);
1803     SetSize(GetSize().GetWidth() + 44, GetSize().GetHeight() + 10);
1804 #endif
1805 }
1806
1807 void CAboutDialog::OnButtonOK(wxCommandEvent& event)
1808 {
1809     EndModal(false);
1810 }
1811
1812
1813
1814
1815
1816
1817 //////////////////////////////////////////////////////////////////////////////
1818 //
1819 // CSendDialog
1820 //
1821
1822 CSendDialog::CSendDialog(wxWindow* parent, const wxString& strAddress) : CSendDialogBase(parent)
1823 {
1824     // Init
1825     m_textCtrlAddress->SetValue(strAddress);
1826     m_choiceTransferType->SetSelection(0);
1827     m_bitmapCheckMark->Show(false);
1828     fEnabledPrev = true;
1829     m_textCtrlAddress->SetFocus();
1830
1831     //// todo: should add a display of your balance for convenience
1832 #ifndef __WXMSW__
1833     wxFont fontTmp = m_staticTextInstructions->GetFont();
1834     if (fontTmp.GetPointSize() > 9);
1835         fontTmp.SetPointSize(9);
1836     m_staticTextInstructions->SetFont(fontTmp);
1837     SetSize(725, 180);
1838 #endif
1839
1840     // Set Icon
1841     wxIcon iconSend;
1842     iconSend.CopyFromBitmap(wxBitmap(send16noshadow_xpm));
1843     SetIcon(iconSend);
1844
1845     // Fixup the tab order
1846     m_buttonPaste->MoveAfterInTabOrder(m_buttonCancel);
1847     m_buttonAddress->MoveAfterInTabOrder(m_buttonPaste);
1848     this->Layout();
1849 }
1850
1851 void CSendDialog::OnKillFocusAmount(wxFocusEvent& event)
1852 {
1853     // Reformat the amount
1854     event.Skip();
1855     if (m_textCtrlAmount->GetValue().Trim().empty())
1856         return;
1857     int64 nTmp;
1858     if (ParseMoney(m_textCtrlAmount->GetValue(), nTmp))
1859         m_textCtrlAmount->SetValue(FormatMoney(nTmp));
1860 }
1861
1862 void CSendDialog::OnButtonAddressBook(wxCommandEvent& event)
1863 {
1864     // Open address book
1865     CAddressBookDialog dialog(this, m_textCtrlAddress->GetValue(), CAddressBookDialog::SENDING, true);
1866     if (dialog.ShowModal())
1867         m_textCtrlAddress->SetValue(dialog.GetSelectedAddress());
1868 }
1869
1870 void CSendDialog::OnButtonPaste(wxCommandEvent& event)
1871 {
1872     // Copy clipboard to address box
1873     if (wxTheClipboard->Open())
1874     {
1875         if (wxTheClipboard->IsSupported(wxDF_TEXT))
1876         {
1877             wxTextDataObject data;
1878             wxTheClipboard->GetData(data);
1879             m_textCtrlAddress->SetValue(data.GetText());
1880         }
1881         wxTheClipboard->Close();
1882     }
1883 }
1884
1885 void CSendDialog::OnButtonSend(wxCommandEvent& event)
1886 {
1887     static CCriticalSection cs_sendlock;
1888     TRY_CRITICAL_BLOCK(cs_sendlock)
1889     {
1890         CWalletTx wtx;
1891         string strAddress = (string)m_textCtrlAddress->GetValue();
1892
1893         // Parse amount
1894         int64 nValue = 0;
1895         if (!ParseMoney(m_textCtrlAmount->GetValue(), nValue) || nValue <= 0)
1896         {
1897             wxMessageBox(_("Error in amount  "), _("Send Coins"));
1898             return;
1899         }
1900         if (nValue > GetBalance())
1901         {
1902             wxMessageBox(_("Amount exceeds your balance  "), _("Send Coins"));
1903             return;
1904         }
1905         if (nValue + nTransactionFee > GetBalance())
1906         {
1907             wxMessageBox(string(_("Total exceeds your balance when the ")) + FormatMoney(nTransactionFee) + _(" transaction fee is included  "), _("Send Coins"));
1908             return;
1909         }
1910
1911         // Parse bitcoin address
1912         uint160 hash160;
1913         bool fBitcoinAddress = AddressToHash160(strAddress, hash160);
1914
1915         if (fBitcoinAddress)
1916         {
1917             CRITICAL_BLOCK(cs_main)
1918             {
1919                 // Send to bitcoin address
1920                 CScript scriptPubKey;
1921                 scriptPubKey << OP_DUP << OP_HASH160 << hash160 << OP_EQUALVERIFY << OP_CHECKSIG;
1922
1923                 string strError = SendMoney(scriptPubKey, nValue, wtx, true);
1924                 if (strError == "")
1925                     wxMessageBox(_("Payment sent  "), _("Sending..."));
1926                 else if (strError == "ABORTED")
1927                     return; // leave send dialog open
1928                 else
1929                 {
1930                     wxMessageBox(strError + "  ", _("Sending..."));
1931                     EndModal(false);
1932                 }
1933             }
1934         }
1935         else
1936         {
1937             // Parse IP address
1938             CAddress addr(strAddress);
1939             if (!addr.IsValid())
1940             {
1941                 wxMessageBox(_("Invalid address  "), _("Send Coins"));
1942                 return;
1943             }
1944
1945             // Message
1946             wtx.mapValue["to"] = strAddress;
1947
1948             // Send to IP address
1949             CSendingDialog* pdialog = new CSendingDialog(this, addr, nValue, wtx);
1950             if (!pdialog->ShowModal())
1951                 return;
1952         }
1953
1954         CRITICAL_BLOCK(cs_mapAddressBook)
1955             if (!mapAddressBook.count(strAddress))
1956                 SetAddressBookName(strAddress, "");
1957
1958         EndModal(true);
1959     }
1960 }
1961
1962 void CSendDialog::OnButtonCancel(wxCommandEvent& event)
1963 {
1964     // Cancel
1965     EndModal(false);
1966 }
1967
1968
1969
1970
1971
1972
1973 //////////////////////////////////////////////////////////////////////////////
1974 //
1975 // CSendingDialog
1976 //
1977
1978 CSendingDialog::CSendingDialog(wxWindow* parent, const CAddress& addrIn, int64 nPriceIn, const CWalletTx& wtxIn) : CSendingDialogBase(NULL) // we have to give null so parent can't destroy us
1979 {
1980     addr = addrIn;
1981     nPrice = nPriceIn;
1982     wtx = wtxIn;
1983     start = wxDateTime::UNow();
1984     memset(pszStatus, 0, sizeof(pszStatus));
1985     fCanCancel = true;
1986     fAbort = false;
1987     fSuccess = false;
1988     fUIDone = false;
1989     fWorkDone = false;
1990 #ifndef __WXMSW__
1991     SetSize(1.2 * GetSize().GetWidth(), 1.08 * GetSize().GetHeight());
1992 #endif
1993
1994     SetTitle(strprintf(_("Sending %s to %s"), FormatMoney(nPrice).c_str(), wtx.mapValue["to"].c_str()));
1995     m_textCtrlStatus->SetValue("");
1996
1997     CreateThread(SendingDialogStartTransfer, this);
1998 }
1999
2000 CSendingDialog::~CSendingDialog()
2001 {
2002     printf("~CSendingDialog()\n");
2003 }
2004
2005 void CSendingDialog::Close()
2006 {
2007     // Last one out turn out the lights.
2008     // fWorkDone signals that work side is done and UI thread should call destroy.
2009     // fUIDone signals that UI window has closed and work thread should call destroy.
2010     // This allows the window to disappear and end modality when cancelled
2011     // without making the user wait for ConnectNode to return.  The dialog object
2012     // hangs around in the background until the work thread exits.
2013     if (IsModal())
2014         EndModal(fSuccess);
2015     else
2016         Show(false);
2017     if (fWorkDone)
2018         Destroy();
2019     else
2020         fUIDone = true;
2021 }
2022
2023 void CSendingDialog::OnClose(wxCloseEvent& event)
2024 {
2025     if (!event.CanVeto() || fWorkDone || fAbort || !fCanCancel)
2026     {
2027         Close();
2028     }
2029     else
2030     {
2031         event.Veto();
2032         wxCommandEvent cmdevent;
2033         OnButtonCancel(cmdevent);
2034     }
2035 }
2036
2037 void CSendingDialog::OnButtonOK(wxCommandEvent& event)
2038 {
2039     if (fWorkDone)
2040         Close();
2041 }
2042
2043 void CSendingDialog::OnButtonCancel(wxCommandEvent& event)
2044 {
2045     if (fCanCancel)
2046         fAbort = true;
2047 }
2048
2049 void CSendingDialog::OnPaint(wxPaintEvent& event)
2050 {
2051     event.Skip();
2052     if (strlen(pszStatus) > 130)
2053         m_textCtrlStatus->SetValue(string("\n") + pszStatus);
2054     else
2055         m_textCtrlStatus->SetValue(string("\n\n") + pszStatus);
2056     m_staticTextSending->SetFocus();
2057     if (!fCanCancel)
2058         m_buttonCancel->Enable(false);
2059     if (fWorkDone)
2060     {
2061         m_buttonOK->Enable(true);
2062         m_buttonOK->SetFocus();
2063         m_buttonCancel->Enable(false);
2064     }
2065     if (fAbort && fCanCancel && IsShown())
2066     {
2067         strcpy(pszStatus, _("CANCELLED"));
2068         m_buttonOK->Enable(true);
2069         m_buttonOK->SetFocus();
2070         m_buttonCancel->Enable(false);
2071         m_buttonCancel->SetLabel(_("Cancelled"));
2072         Close();
2073         wxMessageBox(_("Transfer cancelled  "), _("Sending..."), wxOK, this);
2074     }
2075 }
2076
2077
2078 //
2079 // Everything from here on is not in the UI thread and must only communicate
2080 // with the rest of the dialog through variables and calling repaint.
2081 //
2082
2083 void CSendingDialog::Repaint()
2084 {
2085     Refresh();
2086     wxPaintEvent event;
2087     GetEventHandler()->AddPendingEvent(event);
2088 }
2089
2090 bool CSendingDialog::Status()
2091 {
2092     if (fUIDone)
2093     {
2094         Destroy();
2095         return false;
2096     }
2097     if (fAbort && fCanCancel)
2098     {
2099         memset(pszStatus, 0, 10);
2100         strcpy(pszStatus, _("CANCELLED"));
2101         Repaint();
2102         fWorkDone = true;
2103         return false;
2104     }
2105     return true;
2106 }
2107
2108 bool CSendingDialog::Status(const string& str)
2109 {
2110     if (!Status())
2111         return false;
2112
2113     // This can be read by the UI thread at any time,
2114     // so copy in a way that can be read cleanly at all times.
2115     memset(pszStatus, 0, min(str.size()+1, sizeof(pszStatus)));
2116     strlcpy(pszStatus, str.c_str(), sizeof(pszStatus));
2117
2118     Repaint();
2119     return true;
2120 }
2121
2122 bool CSendingDialog::Error(const string& str)
2123 {
2124     fCanCancel = false;
2125     fWorkDone = true;
2126     Status(string(_("Error: ")) + str);
2127     return false;
2128 }
2129
2130 void SendingDialogStartTransfer(void* parg)
2131 {
2132     ((CSendingDialog*)parg)->StartTransfer();
2133 }
2134
2135 void CSendingDialog::StartTransfer()
2136 {
2137     // Make sure we have enough money
2138     if (nPrice + nTransactionFee > GetBalance())
2139     {
2140         Error(_("Insufficient funds"));
2141         return;
2142     }
2143
2144     // We may have connected already for product details
2145     if (!Status(_("Connecting...")))
2146         return;
2147     CNode* pnode = ConnectNode(addr, 15 * 60);
2148     if (!pnode)
2149     {
2150         Error(_("Unable to connect"));
2151         return;
2152     }
2153
2154     // Send order to seller, with response going to OnReply2 via event handler
2155     if (!Status(_("Requesting public key...")))
2156         return;
2157     pnode->PushRequest("checkorder", wtx, SendingDialogOnReply2, this);
2158 }
2159
2160 void SendingDialogOnReply2(void* parg, CDataStream& vRecv)
2161 {
2162     ((CSendingDialog*)parg)->OnReply2(vRecv);
2163 }
2164
2165 void CSendingDialog::OnReply2(CDataStream& vRecv)
2166 {
2167     if (!Status(_("Received public key...")))
2168         return;
2169
2170     CScript scriptPubKey;
2171     int nRet;
2172     try
2173     {
2174         vRecv >> nRet;
2175         if (nRet > 0)
2176         {
2177             string strMessage;
2178             if (!vRecv.empty())
2179                 vRecv >> strMessage;
2180             if (nRet == 2)
2181                 Error(_("Recipient is not accepting transactions sent by IP address"));
2182             else
2183                 Error(_("Transfer was not accepted"));
2184             //// todo: enlarge the window and enable a hidden white box to put seller's message
2185             return;
2186         }
2187         vRecv >> scriptPubKey;
2188     }
2189     catch (...)
2190     {
2191         //// what do we want to do about this?
2192         Error(_("Invalid response received"));
2193         return;
2194     }
2195
2196     // Pause to give the user a chance to cancel
2197     while (wxDateTime::UNow() < start + wxTimeSpan(0, 0, 0, 2 * 1000))
2198     {
2199         Sleep(200);
2200         if (!Status())
2201             return;
2202     }
2203
2204     CRITICAL_BLOCK(cs_main)
2205     {
2206         // Pay
2207         if (!Status(_("Creating transaction...")))
2208             return;
2209         if (nPrice + nTransactionFee > GetBalance())
2210         {
2211             Error(_("Insufficient funds"));
2212             return;
2213         }
2214         CReserveKey reservekey;
2215         int64 nFeeRequired;
2216         if (!CreateTransaction(scriptPubKey, nPrice, wtx, reservekey, nFeeRequired))
2217         {
2218             if (nPrice + nFeeRequired > GetBalance())
2219                 Error(strprintf(_("This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds"), FormatMoney(nFeeRequired).c_str()));
2220             else
2221                 Error(_("Transaction creation failed"));
2222             return;
2223         }
2224
2225         // Transaction fee
2226         if (!ThreadSafeAskFee(nFeeRequired, _("Sending..."), this))
2227         {
2228             Error(_("Transaction aborted"));
2229             return;
2230         }
2231
2232         // Make sure we're still connected
2233         CNode* pnode = ConnectNode(addr, 2 * 60 * 60);
2234         if (!pnode)
2235         {
2236             Error(_("Lost connection, transaction cancelled"));
2237             return;
2238         }
2239
2240         // Last chance to cancel
2241         Sleep(50);
2242         if (!Status())
2243             return;
2244         fCanCancel = false;
2245         if (fAbort)
2246         {
2247             fCanCancel = true;
2248             if (!Status())
2249                 return;
2250             fCanCancel = false;
2251         }
2252         if (!Status(_("Sending payment...")))
2253             return;
2254
2255         // Commit
2256         if (!CommitTransaction(wtx, reservekey))
2257         {
2258             Error(_("The transaction was rejected.  This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here."));
2259             return;
2260         }
2261
2262         // Send payment tx to seller, with response going to OnReply3 via event handler
2263         CWalletTx wtxSend = wtx;
2264         wtxSend.fFromMe = false;
2265         pnode->PushRequest("submitorder", wtxSend, SendingDialogOnReply3, this);
2266
2267         Status(_("Waiting for confirmation..."));
2268         MainFrameRepaint();
2269     }
2270 }
2271
2272 void SendingDialogOnReply3(void* parg, CDataStream& vRecv)
2273 {
2274     ((CSendingDialog*)parg)->OnReply3(vRecv);
2275 }
2276
2277 void CSendingDialog::OnReply3(CDataStream& vRecv)
2278 {
2279     int nRet;
2280     try
2281     {
2282         vRecv >> nRet;
2283         if (nRet > 0)
2284         {
2285             Error(_("The payment was sent, but the recipient was unable to verify it.\n"
2286                     "The transaction is recorded and will credit to the recipient,\n"
2287                     "but the comment information will be blank."));
2288             return;
2289         }
2290     }
2291     catch (...)
2292     {
2293         //// what do we want to do about this?
2294         Error(_("Payment was sent, but an invalid response was received"));
2295         return;
2296     }
2297
2298     fSuccess = true;
2299     fWorkDone = true;
2300     Status(_("Payment completed"));
2301 }
2302
2303
2304
2305
2306
2307
2308 //////////////////////////////////////////////////////////////////////////////
2309 //
2310 // CAddressBookDialog
2311 //
2312
2313 CAddressBookDialog::CAddressBookDialog(wxWindow* parent, const wxString& strInitSelected, int nPageIn, bool fDuringSendIn) : CAddressBookDialogBase(parent)
2314 {
2315     // Set initially selected page
2316     wxNotebookEvent event;
2317     event.SetSelection(nPageIn);
2318     OnNotebookPageChanged(event);
2319     m_notebook->ChangeSelection(nPageIn);
2320
2321     fDuringSend = fDuringSendIn;
2322     if (!fDuringSend)
2323         m_buttonCancel->Show(false);
2324
2325     // Set Icon
2326     wxIcon iconAddressBook;
2327     iconAddressBook.CopyFromBitmap(wxBitmap(addressbook16_xpm));
2328     SetIcon(iconAddressBook);
2329
2330     // Init column headers
2331     m_listCtrlSending->InsertColumn(0, _("Name"), wxLIST_FORMAT_LEFT, 200);
2332     m_listCtrlSending->InsertColumn(1, _("Address"), wxLIST_FORMAT_LEFT, 350);
2333     m_listCtrlSending->SetFocus();
2334     m_listCtrlReceiving->InsertColumn(0, _("Label"), wxLIST_FORMAT_LEFT, 200);
2335     m_listCtrlReceiving->InsertColumn(1, _("Bitcoin Address"), wxLIST_FORMAT_LEFT, 350);
2336     m_listCtrlReceiving->SetFocus();
2337
2338     // Fill listctrl with address book data
2339     CRITICAL_BLOCK(cs_mapKeys)
2340     CRITICAL_BLOCK(cs_mapAddressBook)
2341     {
2342         string strDefaultReceiving = (string)pframeMain->m_textCtrlAddress->GetValue();
2343         foreach(const PAIRTYPE(string, string)& item, mapAddressBook)
2344         {
2345             string strAddress = item.first;
2346             string strName = item.second;
2347             uint160 hash160;
2348             bool fMine = (AddressToHash160(strAddress, hash160) && mapPubKeys.count(hash160));
2349             wxListCtrl* plistCtrl = fMine ? m_listCtrlReceiving : m_listCtrlSending;
2350             int nIndex = InsertLine(plistCtrl, strName, strAddress);
2351             if (strAddress == (fMine ? strDefaultReceiving : string(strInitSelected)))
2352                 plistCtrl->SetItemState(nIndex, wxLIST_STATE_SELECTED|wxLIST_STATE_FOCUSED, wxLIST_STATE_SELECTED|wxLIST_STATE_FOCUSED);
2353         }
2354     }
2355 }
2356
2357 wxString CAddressBookDialog::GetSelectedAddress()
2358 {
2359     int nIndex = GetSelection(m_listCtrl);
2360     if (nIndex == -1)
2361         return "";
2362     return GetItemText(m_listCtrl, nIndex, 1);
2363 }
2364
2365 wxString CAddressBookDialog::GetSelectedSendingAddress()
2366 {
2367     int nIndex = GetSelection(m_listCtrlSending);
2368     if (nIndex == -1)
2369         return "";
2370     return GetItemText(m_listCtrlSending, nIndex, 1);
2371 }
2372
2373 wxString CAddressBookDialog::GetSelectedReceivingAddress()
2374 {
2375     int nIndex = GetSelection(m_listCtrlReceiving);
2376     if (nIndex == -1)
2377         return "";
2378     return GetItemText(m_listCtrlReceiving, nIndex, 1);
2379 }
2380
2381 void CAddressBookDialog::OnNotebookPageChanged(wxNotebookEvent& event)
2382 {
2383     event.Skip();
2384     nPage = event.GetSelection();
2385     if (nPage == SENDING)
2386         m_listCtrl = m_listCtrlSending;
2387     else if (nPage == RECEIVING)
2388         m_listCtrl = m_listCtrlReceiving;
2389     m_buttonDelete->Show(nPage == SENDING);
2390     m_buttonCopy->Show(nPage == RECEIVING);
2391     this->Layout();
2392     m_listCtrl->SetFocus();
2393 }
2394
2395 void CAddressBookDialog::OnListEndLabelEdit(wxListEvent& event)
2396 {
2397     // Update address book with edited name
2398     event.Skip();
2399     if (event.IsEditCancelled())
2400         return;
2401     string strAddress = (string)GetItemText(m_listCtrl, event.GetIndex(), 1);
2402     SetAddressBookName(strAddress, string(event.GetText()));
2403     pframeMain->RefreshListCtrl();
2404 }
2405
2406 void CAddressBookDialog::OnListItemSelected(wxListEvent& event)
2407 {
2408     event.Skip();
2409     if (nPage == RECEIVING)
2410         SetDefaultReceivingAddress((string)GetSelectedReceivingAddress());
2411 }
2412
2413 void CAddressBookDialog::OnListItemActivated(wxListEvent& event)
2414 {
2415     event.Skip();
2416     if (fDuringSend)
2417     {
2418         // Doubleclick returns selection
2419         EndModal(GetSelectedAddress() != "" ? 2 : 0);
2420         return;
2421     }
2422
2423     // Doubleclick edits item
2424     wxCommandEvent event2;
2425     OnButtonEdit(event2);
2426 }
2427
2428 void CAddressBookDialog::OnButtonDelete(wxCommandEvent& event)
2429 {
2430     if (nPage != SENDING)
2431         return;
2432     for (int nIndex = m_listCtrl->GetItemCount()-1; nIndex >= 0; nIndex--)
2433     {
2434         if (m_listCtrl->GetItemState(nIndex, wxLIST_STATE_SELECTED))
2435         {
2436             string strAddress = (string)GetItemText(m_listCtrl, nIndex, 1);
2437             CWalletDB().EraseName(strAddress);
2438             m_listCtrl->DeleteItem(nIndex);
2439         }
2440     }
2441     pframeMain->RefreshListCtrl();
2442 }
2443
2444 void CAddressBookDialog::OnButtonCopy(wxCommandEvent& event)
2445 {
2446     // Copy address box to clipboard
2447     if (wxTheClipboard->Open())
2448     {
2449         wxTheClipboard->SetData(new wxTextDataObject(GetSelectedAddress()));
2450         wxTheClipboard->Close();
2451     }
2452 }
2453
2454 bool CAddressBookDialog::CheckIfMine(const string& strAddress, const string& strTitle)
2455 {
2456     uint160 hash160;
2457     bool fMine = (AddressToHash160(strAddress, hash160) && mapPubKeys.count(hash160));
2458     if (fMine)
2459         wxMessageBox(_("This is one of your own addresses for receiving payments and cannot be entered in the address book.  "), strTitle);
2460     return fMine;
2461 }
2462
2463 void CAddressBookDialog::OnButtonEdit(wxCommandEvent& event)
2464 {
2465     int nIndex = GetSelection(m_listCtrl);
2466     if (nIndex == -1)
2467         return;
2468     string strName = (string)m_listCtrl->GetItemText(nIndex);
2469     string strAddress = (string)GetItemText(m_listCtrl, nIndex, 1);
2470     string strAddressOrg = strAddress;
2471
2472     if (nPage == SENDING)
2473     {
2474         // Ask name and address
2475         do
2476         {
2477             CGetTextFromUserDialog dialog(this, _("Edit Address"), _("Name"), strName, _("Address"), strAddress);
2478             if (!dialog.ShowModal())
2479                 return;
2480             strName = dialog.GetValue1();
2481             strAddress = dialog.GetValue2();
2482         }
2483         while (CheckIfMine(strAddress, _("Edit Address")));
2484
2485     }
2486     else if (nPage == RECEIVING)
2487     {
2488         // Ask name
2489         CGetTextFromUserDialog dialog(this, _("Edit Address Label"), _("Label"), strName);
2490         if (!dialog.ShowModal())
2491             return;
2492         strName = dialog.GetValue();
2493     }
2494
2495     // Write back
2496     if (strAddress != strAddressOrg)
2497         CWalletDB().EraseName(strAddressOrg);
2498     SetAddressBookName(strAddress, strName);
2499     m_listCtrl->SetItem(nIndex, 1, strAddress);
2500     m_listCtrl->SetItemText(nIndex, strName);
2501     pframeMain->RefreshListCtrl();
2502 }
2503
2504 void CAddressBookDialog::OnButtonNew(wxCommandEvent& event)
2505 {
2506     string strName;
2507     string strAddress;
2508
2509     if (nPage == SENDING)
2510     {
2511         // Ask name and address
2512         do
2513         {
2514             CGetTextFromUserDialog dialog(this, _("Add Address"), _("Name"), strName, _("Address"), strAddress);
2515             if (!dialog.ShowModal())
2516                 return;
2517             strName = dialog.GetValue1();
2518             strAddress = dialog.GetValue2();
2519         }
2520         while (CheckIfMine(strAddress, _("Add Address")));
2521     }
2522     else if (nPage == RECEIVING)
2523     {
2524         // Ask name
2525         CGetTextFromUserDialog dialog(this,
2526             _("New Receiving Address"),
2527             _("You should use a new address for each payment you receive.\n\nLabel"),
2528             "");
2529         if (!dialog.ShowModal())
2530             return;
2531         strName = dialog.GetValue();
2532
2533         // Generate new key
2534         strAddress = PubKeyToAddress(GetKeyFromKeyPool());
2535     }
2536
2537     // Add to list and select it
2538     SetAddressBookName(strAddress, strName);
2539     int nIndex = InsertLine(m_listCtrl, strName, strAddress);
2540     SetSelection(m_listCtrl, nIndex);
2541     m_listCtrl->SetFocus();
2542     if (nPage == SENDING)
2543         pframeMain->RefreshListCtrl();
2544 }
2545
2546 void CAddressBookDialog::OnButtonOK(wxCommandEvent& event)
2547 {
2548     // OK
2549     EndModal(GetSelectedAddress() != "" ? 1 : 0);
2550 }
2551
2552 void CAddressBookDialog::OnButtonCancel(wxCommandEvent& event)
2553 {
2554     // Cancel
2555     EndModal(0);
2556 }
2557
2558 void CAddressBookDialog::OnClose(wxCloseEvent& event)
2559 {
2560     // Close
2561     EndModal(0);
2562 }
2563
2564
2565
2566
2567
2568
2569 //////////////////////////////////////////////////////////////////////////////
2570 //
2571 // CMyTaskBarIcon
2572 //
2573
2574 enum
2575 {
2576     ID_TASKBAR_RESTORE = 10001,
2577     ID_TASKBAR_SEND,
2578     ID_TASKBAR_OPTIONS,
2579     ID_TASKBAR_GENERATE,
2580     ID_TASKBAR_EXIT,
2581 };
2582
2583 BEGIN_EVENT_TABLE(CMyTaskBarIcon, wxTaskBarIcon)
2584     EVT_TASKBAR_LEFT_DCLICK(CMyTaskBarIcon::OnLeftButtonDClick)
2585     EVT_MENU(ID_TASKBAR_RESTORE, CMyTaskBarIcon::OnMenuRestore)
2586     EVT_MENU(ID_TASKBAR_SEND, CMyTaskBarIcon::OnMenuSend)
2587     EVT_MENU(ID_TASKBAR_OPTIONS, CMyTaskBarIcon::OnMenuOptions)
2588     EVT_UPDATE_UI(ID_TASKBAR_GENERATE, CMyTaskBarIcon::OnUpdateUIGenerate)
2589     EVT_MENU(ID_TASKBAR_EXIT, CMyTaskBarIcon::OnMenuExit)
2590 END_EVENT_TABLE()
2591
2592 void CMyTaskBarIcon::Show(bool fShow)
2593 {
2594     static char pszPrevTip[200];
2595     if (fShow)
2596     {
2597         string strTooltip = _("Bitcoin");
2598         if (fGenerateBitcoins)
2599             strTooltip = _("Bitcoin - Generating");
2600         if (fGenerateBitcoins && vNodes.empty())
2601             strTooltip = _("Bitcoin - (not connected)");
2602
2603         // Optimization, only update when changed, using char array to be reentrant
2604         if (strncmp(pszPrevTip, strTooltip.c_str(), sizeof(pszPrevTip)-1) != 0)
2605         {
2606             strlcpy(pszPrevTip, strTooltip.c_str(), sizeof(pszPrevTip));
2607 #ifdef __WXMSW__
2608             // somehow it'll choose the wrong size and scale it down if
2609             // we use the main icon, so we hand it one with only 16x16
2610             SetIcon(wxICON(favicon), strTooltip);
2611 #else
2612             SetIcon(bitcoin80_xpm, strTooltip);
2613 #endif
2614         }
2615     }
2616     else
2617     {
2618         strlcpy(pszPrevTip, "", sizeof(pszPrevTip));
2619         RemoveIcon();
2620     }
2621 }
2622
2623 void CMyTaskBarIcon::Hide()
2624 {
2625     Show(false);
2626 }
2627
2628 void CMyTaskBarIcon::OnLeftButtonDClick(wxTaskBarIconEvent& event)
2629 {
2630     Restore();
2631 }
2632
2633 void CMyTaskBarIcon::OnMenuRestore(wxCommandEvent& event)
2634 {
2635     Restore();
2636 }
2637
2638 void CMyTaskBarIcon::OnMenuSend(wxCommandEvent& event)
2639 {
2640     // Taskbar: Send
2641     CSendDialog dialog(pframeMain);
2642     dialog.ShowModal();
2643 }
2644
2645 void CMyTaskBarIcon::OnMenuOptions(wxCommandEvent& event)
2646 {
2647     // Since it's modal, get the main window to do it
2648     wxCommandEvent event2(wxEVT_COMMAND_MENU_SELECTED, wxID_PREFERENCES);
2649     pframeMain->GetEventHandler()->AddPendingEvent(event2);
2650 }
2651
2652 void CMyTaskBarIcon::Restore()
2653 {
2654     pframeMain->Show();
2655     wxIconizeEvent event(0, false);
2656     pframeMain->GetEventHandler()->AddPendingEvent(event);
2657     pframeMain->Iconize(false);
2658     pframeMain->Raise();
2659 }
2660
2661 void CMyTaskBarIcon::OnUpdateUIGenerate(wxUpdateUIEvent& event)
2662 {
2663     event.Check(fGenerateBitcoins);
2664 }
2665
2666 void CMyTaskBarIcon::OnMenuExit(wxCommandEvent& event)
2667 {
2668     pframeMain->Close(true);
2669 }
2670
2671 void CMyTaskBarIcon::UpdateTooltip()
2672 {
2673     if (IsIconInstalled())
2674         Show(true);
2675 }
2676
2677 wxMenu* CMyTaskBarIcon::CreatePopupMenu()
2678 {
2679     wxMenu* pmenu = new wxMenu;
2680     pmenu->Append(ID_TASKBAR_RESTORE, _("&Open Bitcoin"));
2681     pmenu->Append(ID_TASKBAR_SEND, _("&Send Bitcoins"));
2682     pmenu->Append(ID_TASKBAR_OPTIONS, _("O&ptions..."));
2683 #ifndef __WXMAC_OSX__ // Mac has built-in quit menu
2684     pmenu->AppendSeparator();
2685     pmenu->Append(ID_TASKBAR_EXIT, _("E&xit"));
2686 #endif
2687     return pmenu;
2688 }
2689
2690
2691
2692
2693
2694
2695 //////////////////////////////////////////////////////////////////////////////
2696 //
2697 // CMyApp
2698 //
2699
2700 void CreateMainWindow()
2701 {
2702     pframeMain = new CMainFrame(NULL);
2703     if (GetBoolArg("-min"))
2704         pframeMain->Iconize(true);
2705 #if defined(__WXGTK__) || defined(__WXMAC_OSX__)
2706     if (!GetBoolArg("-minimizetotray"))
2707         fMinimizeToTray = false;
2708 #endif
2709     pframeMain->Show(true);  // have to show first to get taskbar button to hide
2710     if (fMinimizeToTray && pframeMain->IsIconized())
2711         fClosedToTray = true;
2712     pframeMain->Show(!fClosedToTray);
2713     ptaskbaricon->Show(fMinimizeToTray || fClosedToTray);
2714     CreateThread(ThreadDelayedRepaint, NULL);
2715 }
2716
2717
2718 // Define a new application
2719 class CMyApp : public wxApp
2720 {
2721 public:
2722     CMyApp(){};
2723     ~CMyApp(){};
2724     bool OnInit();
2725     bool OnInit2();
2726     int OnExit();
2727
2728     // Hook Initialize so we can start without GUI
2729     virtual bool Initialize(int& argc, wxChar** argv);
2730
2731     // 2nd-level exception handling: we get all the exceptions occurring in any
2732     // event handler here
2733     virtual bool OnExceptionInMainLoop();
2734
2735     // 3rd, and final, level exception handling: whenever an unhandled
2736     // exception is caught, this function is called
2737     virtual void OnUnhandledException();
2738
2739     // and now for something different: this function is called in case of a
2740     // crash (e.g. dereferencing null pointer, division by 0, ...)
2741     virtual void OnFatalException();
2742 };
2743
2744 IMPLEMENT_APP(CMyApp)
2745
2746 bool CMyApp::Initialize(int& argc, wxChar** argv)
2747 {
2748     for (int i = 1; i < argc; i++)
2749         if (!IsSwitchChar(argv[i][0]))
2750             fCommandLine = true;
2751
2752     if (!fCommandLine)
2753     {
2754         // wxApp::Initialize will remove environment-specific parameters,
2755         // so it's too early to call ParseParameters yet
2756         for (int i = 1; i < argc; i++)
2757         {
2758             wxString str = argv[i];
2759             #ifdef __WXMSW__
2760             if (str.size() >= 1 && str[0] == '/')
2761                 str[0] = '-';
2762             char pszLower[MAX_PATH];
2763             strlcpy(pszLower, str.c_str(), sizeof(pszLower));
2764             strlwr(pszLower);
2765             str = pszLower;
2766             #endif
2767             if (str == "-daemon")
2768                 fDaemon = true;
2769         }
2770     }
2771
2772 #ifdef __WXGTK__
2773     if (fDaemon || fCommandLine)
2774     {
2775         // Call the original Initialize while suppressing error messages
2776         // and ignoring failure.  If unable to initialize GTK, it fails
2777         // near the end so hopefully the last few things don't matter.
2778         {
2779             wxLogNull logNo;
2780             wxApp::Initialize(argc, argv);
2781         }
2782
2783         if (fDaemon)
2784         {
2785             // Daemonize
2786             pid_t pid = fork();
2787             if (pid < 0)
2788             {
2789                 fprintf(stderr, "Error: fork() returned %d errno %d\n", pid, errno);
2790                 return false;
2791             }
2792             if (pid > 0)
2793                 pthread_exit((void*)0);
2794
2795             pid_t sid = setsid();
2796             if (sid < 0)
2797                 fprintf(stderr, "Error: setsid() returned %d errno %d\n", sid, errno);
2798         }
2799
2800         return true;
2801     }
2802 #endif
2803
2804     return wxApp::Initialize(argc, argv);
2805 }
2806
2807 bool CMyApp::OnInit()
2808 {
2809 #if defined(__WXMSW__) && defined(__WXDEBUG__) && defined(GUI)
2810     // Disable malfunctioning wxWidgets debug assertion
2811     extern int g_isPainting;
2812     g_isPainting = 10000;
2813 #endif
2814 #if defined(__WXMSW__ ) || defined(__WXMAC_OSX__)
2815     SetAppName("Bitcoin");
2816 #else
2817     SetAppName("bitcoin");
2818 #endif
2819 #ifdef __WXMSW__
2820 #if wxUSE_UNICODE
2821     // Hack to set wxConvLibc codepage to UTF-8 on Windows,
2822     // may break if wxMBConv_win32 implementation in strconv.cpp changes.
2823     class wxMBConv_win32 : public wxMBConv
2824     {
2825     public:
2826         long m_CodePage;
2827         size_t m_minMBCharWidth;
2828     };
2829     if (((wxMBConv_win32*)&wxConvLibc)->m_CodePage == CP_ACP)
2830         ((wxMBConv_win32*)&wxConvLibc)->m_CodePage = CP_UTF8;
2831 #endif
2832 #endif
2833
2834     // Load locale/<lang>/LC_MESSAGES/bitcoin.mo language file
2835     g_locale.Init(wxLANGUAGE_DEFAULT, 0);
2836     g_locale.AddCatalogLookupPathPrefix("locale");
2837 #ifndef __WXMSW__
2838     g_locale.AddCatalogLookupPathPrefix("/usr/share/locale");
2839     g_locale.AddCatalogLookupPathPrefix("/usr/local/share/locale");
2840 #endif
2841     g_locale.AddCatalog("wxstd"); // wxWidgets standard translations, if any
2842     g_locale.AddCatalog("bitcoin");
2843
2844     return AppInit(argc, argv);
2845 }
2846
2847 int CMyApp::OnExit()
2848 {
2849     Shutdown(NULL);
2850     return wxApp::OnExit();
2851 }
2852
2853 bool CMyApp::OnExceptionInMainLoop()
2854 {
2855     try
2856     {
2857         throw;
2858     }
2859     catch (std::exception& e)
2860     {
2861         PrintException(&e, "CMyApp::OnExceptionInMainLoop()");
2862         wxLogWarning("Exception %s %s", typeid(e).name(), e.what());
2863         Sleep(1000);
2864         throw;
2865     }
2866     catch (...)
2867     {
2868         PrintException(NULL, "CMyApp::OnExceptionInMainLoop()");
2869         wxLogWarning("Unknown exception");
2870         Sleep(1000);
2871         throw;
2872     }
2873     return true;
2874 }
2875
2876 void CMyApp::OnUnhandledException()
2877 {
2878     // this shows how we may let some exception propagate uncaught
2879     try
2880     {
2881         throw;
2882     }
2883     catch (std::exception& e)
2884     {
2885         PrintException(&e, "CMyApp::OnUnhandledException()");
2886         wxLogWarning("Exception %s %s", typeid(e).name(), e.what());
2887         Sleep(1000);
2888         throw;
2889     }
2890     catch (...)
2891     {
2892         PrintException(NULL, "CMyApp::OnUnhandledException()");
2893         wxLogWarning("Unknown exception");
2894         Sleep(1000);
2895         throw;
2896     }
2897 }
2898
2899 void CMyApp::OnFatalException()
2900 {
2901     wxMessageBox(_("Program has crashed and will terminate.  "), "Bitcoin", wxOK | wxICON_ERROR);
2902 }