void SymbolList::ActionList::Find(const wxString& searchtext, bool refresh) {
	m_searchText = searchtext; // cache for later updates

	if (searchtext.empty()) {
		SetAllItems();
		return;
	}

	// Convert to upper case for case insensitive search
	const wxString text = searchtext.Upper();

	m_items.clear();
	vector<unsigned int> hlChars;
	for (unsigned int i = 0; i < m_actions.GetCount(); ++i) {
		const wxString& name = m_actions[i];
		unsigned int charpos = 0;
		wxChar c = text[charpos];
		hlChars.clear();

		for (unsigned int textpos = 0; textpos < name.size(); ++textpos) {
			if ((wxChar)wxToupper(name[textpos]) == c) {
				hlChars.push_back(textpos);
				++charpos;
				if (charpos == text.size()) {
					// All chars found.
					m_items.push_back(aItem(i, &m_actions[i], hlChars));
					break;
				}
				else c = text[charpos];
			}
		}
	}

	sort(m_items.begin(), m_items.end());

	Freeze();
	SetItemCount(m_items.size());
	if (refresh) {
		if (m_items.empty()) SetSelection(-1); // deselect
		else SetSelection(0);

		RefreshAll();
	}
	Thaw();
}

BOOL KBall::SlamDunk(KHero* pSlamer, KBasketSocket* pTargetSocket)
{
    BOOL        bResult            = false;
    BOOL        bRetCode           = false;
    KBasket*    pBasket             = NULL;
    KBODY       cSocketBody;
    KBODY       cSlamerBody;
    KPOSITION   cSlamerDstPos;
    KPOSITION   cBallDstPos;
   
    KGLOG_PROCESS_ERROR(pSlamer && pTargetSocket);

    pBasket = pTargetSocket->m_pBasket; // ûÀº¿ð
    KGLOG_PROCESS_ERROR(pBasket);

    bRetCode = BeUnTake(pSlamer);
    KGLOG_PROCESS_ERROR(bRetCode);

    cSocketBody = pTargetSocket->GetBody();
    cSlamerBody = pSlamer->GetBody();

    if (pTargetSocket->m_eDir == csdRight)
        cSlamerDstPos.nX = cSocketBody.nX + cSocketBody.nLength / 2 + cSlamerBody.nLength;
    else
        cSlamerDstPos.nX = cSocketBody.nX - cSocketBody.nLength / 2 - cSlamerBody.nLength;
    cSlamerDstPos.nY = cSocketBody.nY;
    cSlamerDstPos.nZ = cSocketBody.nZ - CELL_LENGTH * 3;

    pSlamer->EnsureNotStandOnObject();
    pSlamer->SetPosition(cSlamerDstPos);
    pSlamer->ClearVelocity();
    pSlamer->LoseControlByCounter(cdSlamDunkFrameCount);

    cBallDstPos = pTargetSocket->GetPosition();
    SetPosition(cBallDstPos);
    m_dwShooterID   = pSlamer->m_dwID;
    m_dwThrowerID   = ERROR_ID;
    m_pTargetSocket = pTargetSocket;

    Freeze(g_pSO3World->m_Settings.m_ConstList.nSlamBallReboundFrame);

    bResult = true;
Exit0:
    return bRetCode;
}

void WindowStack::DoSelect(wxWindow* win)
{
    Freeze();
    // remove the old selection
    if(m_selection) {
        m_mainSizer->Detach(m_selection);
        m_selection->Hide();
    }
    if(win) {
        m_mainSizer->Add(win, 1, wxEXPAND);
        win->Show();
        m_selection = win;
    } else {
        m_selection = NULL;
    }
    m_mainSizer->Layout();
    Thaw();
}

bool wxFlatNotebook::DeleteAllPages()
{
	if(m_windows.empty())
		return false;

	Freeze();
	int i = 0;
	for(; i<(int)m_windows.GetCount(); i++){
		delete m_windows[i];
	}

	m_windows.Clear();
	Thaw();

	// Clear the container of the tabs as well
	m_pages->DeleteAllPages();
	return true;
}

int MAMain() {
	double d;
	static const char str1[] = "4.56";
	static const char str2[] = "12389.5612323545034954378343";

	InitConsole();
	printf("Hello World.\n");
	printf("1: %s\n", str1);
	d = strtod(str1, NULL);
	printf("d: %f\n", d);
	printf("2: %s\n", str2);
	d = strtod(str2, NULL);
	printf("d: %f\n", d);

	//Freeze
	Freeze(0);
	return 0;
}

void GERBER_LAYER_WIDGET::ReFill()
{
    Freeze();

    ClearLayerRows();

    for( int layer = 0; layer < GERBER_DRAWLAYERS_COUNT; ++layer )
    {
        wxString msg = g_GERBER_List.GetDisplayName( layer );

        AppendLayerRow( LAYER_WIDGET::ROW( msg, layer,
                        myframe->GetLayerColor( layer ), wxEmptyString, true ) );
    }

    Thaw();

    installRightLayerClickHandler();
}

bool WIDGET_HOTKEY_LIST::TransferDefaultsToControl()
{
    Freeze();

    for( wxTreeListItem item = GetFirstItem(); item.IsOk(); item = GetNextItem( item ) )
    {
        WIDGET_HOTKEY_CLIENT_DATA* hkdata = GetHKClientData( item );
        if( hkdata == NULL)
            continue;

        hkdata->GetHotkey().ResetKeyCodeToDefault();
    }

    UpdateFromClientData();
    Thaw();

    return true;
}

void wxTreeCtrlBase::CollapseAllChildren(const wxTreeItemId& item)
{
    Freeze();
    // first (recursively) collapse all the children
    wxTreeItemIdValue cookie;
    for ( wxTreeItemId idCurr = GetFirstChild(item, cookie);
          idCurr.IsOk();
          idCurr = GetNextChild(item, cookie) )
    {
        CollapseAllChildren(idCurr);
    }

    // then collapse this element too unless it's the hidden root which can't
    // be collapsed
    if ( item != GetRootItem() || !HasFlag(wxTR_HIDE_ROOT) )
        Collapse(item);
    Thaw();
}

void BundlePane::OnTreeEndDrag(wxTreeEvent& event) {
	if (!m_draggedItem.IsOk()) return;

	const wxTreeItemId itemSrc = m_draggedItem;
	const wxTreeItemId itemDst = event.GetItem();
	m_draggedItem = wxTreeItemId();

	if (!itemDst.IsOk()) return; // Invalid destintion
	if (itemSrc == itemDst) return; // Can't drag to self
	if (IsTreeItemParentOf(itemSrc, itemDst)) return; // Can't drag to one of your own children

	wxLogDebug(wxT("Ending Drag over item: %s"), m_bundleTree->GetItemText(itemDst).c_str());

	const BundleItemData* srcData = (BundleItemData*)m_bundleTree->GetItemData(itemSrc);
	const BundleItemData* dstData = (BundleItemData*)m_bundleTree->GetItemData(itemDst);

	if (!dstData->IsMenuItem()) return; // You can only drag items to menu
	if (dstData->m_bundleId != srcData->m_bundleId) return; // Items can only be dragged within same bundle

	// We have to cache uuid of submenus
	const wxString subUuid = (srcData->m_type == BUNDLE_SUBDIR) ? srcData->m_uuid : wxString(wxEmptyString);

	const unsigned int bundleId = srcData->m_bundleId;
	PListDict infoDict = GetEditableMenuPlist(bundleId);
	
	// Insert the item
	Freeze();
	const wxString name = m_bundleTree->GetItemText(itemSrc);
	const wxTreeItemId insertedItem = InsertMenuItem(itemDst, name, new BundleItemData(*srcData), infoDict);

	if (srcData->m_type == BUNDLE_SUBDIR) {
		CopySubItems(itemSrc, insertedItem);
	}

	// Delete source ref
	if (srcData->IsMenuItem()) RemoveMenuItem(itemSrc, false, infoDict);
	Thaw();

	// Save the modified plist
	m_plistHandler.SaveBundle(bundleId);

	// Update menu in editorFrame
	m_syntaxHandler.ReParseBundles(true/*onlyMenu*/);
}

VAnnoView::VAnnoView(wxWindow* frame, wxWindow* parent,
	wxWindowID id,
	const wxPoint& pos,
	const wxSize& size,
	long style,
	const wxString& name) :
wxPanel(parent, id, pos, size, style, name),
m_frame(frame),
m_data(0)
{
	SetEvtHandlerEnabled(false);
	Freeze();

	m_root_sizer = new wxBoxSizer(wxVERTICAL);
	wxStaticText* st = 0;

	wxBoxSizer* sizer_1 = new wxBoxSizer(wxHORIZONTAL);
	st = new wxStaticText(this, 0, "Info:",
		wxDefaultPosition, wxDefaultSize);
	sizer_1->Add(10, 10);
	sizer_1->Add(st);

	wxBoxSizer* sizer_2 = new wxBoxSizer(wxHORIZONTAL);
	m_text = new myTextCtrl(frame, this, wxID_ANY, "",
		wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxHSCROLL);
	sizer_2->Add(10, 10);
	sizer_2->Add(m_text, 1, wxEXPAND);
	sizer_2->Add(10, 10);

	
	m_root_sizer->Add(10, 10);
	m_root_sizer->Add(sizer_1, 0, wxALIGN_LEFT);
	m_root_sizer->Add(sizer_2, 1, wxEXPAND);
	m_root_sizer->Add(10, 10);

	//m_root_sizer->Hide(m_roi_root_sizer);
	
	SetSizer(m_root_sizer);
	Layout();

	Thaw();
	SetEvtHandlerEnabled(true);
}

void WIDGET_HOTKEY_LIST::ResetAllHotkeys( bool aResetToDefault )
{
    Freeze();

    // Reset all the hotkeys, not just the ones shown
    // Should not need to check conflicts, as the state we're about
    // to set to a should be consistent
    if( aResetToDefault )
    {
        m_hk_store.ResetAllHotkeysToDefault();
    }
    else
    {
        m_hk_store.ResetAllHotkeysToOriginal();
    }

    UpdateFromClientData();
    Thaw();
}

void BFBackupTree::Init ()
{
    lastItemId_ = wxTreeItemId();

    Freeze();

    // recreate the treeCtrl with all tasks
    BFBackup::Instance().InitThat(this);

    // expand all items in the treeCtlr
    ExpandAll();

	if ( lastItemId_.IsOk() )
		SelectItem(lastItemId_);
	else
		SelectItem(GetRootItem());

    Thaw();
}

bool CDlgMessages::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    CSkinAdvanced*         pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced();
    wxASSERT(pSkinAdvanced);
    wxASSERT(wxDynamicCast(pSkinAdvanced, CSkinAdvanced));

        
    SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);

    wxDialog::Create( parent, id, caption, pos, size, style );

    wxString strCaption = caption;
    if (strCaption.IsEmpty()) {
        strCaption.Printf(_("%s - Notices"), pSkinAdvanced->GetApplicationName().c_str());
    }
    SetTitle(strCaption);

    // Initialize Application Icon
    SetIcons(*pSkinAdvanced->GetApplicationIcon());

    Freeze();

    SetBackgroundStyle(wxBG_STYLE_CUSTOM);

#if TEST_BACKGROUND_WITH_MAGENTA_FILL
    SetBackgroundColour(wxColour(255, 0, 255));
#endif
    SetForegroundColour(*wxBLACK);

    CreateControls();

    GetSizer()->Fit(this);
    GetSizer()->SetSizeHints(this);

    // To work properly on Mac, RestoreState() must be called _after_ 
    //  calling GetSizer()->Fit(), GetSizer()->SetSizeHints() and Center()
    RestoreState();   

    Thaw();

    return true;
}

void LatexPreviewWindow::SetImage(const wxBitmap& img)
{
    Freeze();

    int old_width = 0,
        old_height = 0;
    if (m_img.IsOk()) {
        old_width = m_img.GetWidth();
        old_height = m_img.GetHeight();
    }

    wxSize increase(img.GetWidth() - old_width,
                    img.GetHeight() - old_height),
           frame_size( GetSize() ),
           new_img_size(img.GetWidth() + 40, img.GetHeight() + 40);
    m_img = img;

    // m_mainpanel->Layout();

    // m_control_image->SetVirtualSizeHints( new_img_size );
    m_control_image->SetInitialSize( new_img_size );
    m_control_image->SetMinSize( new_img_size );
    m_control_image->SetSize( new_img_size );

    m_panel_formula->GetSizer()->Layout();
    GetSizer()->SetSizeHints(this);

    if (m_resize_frame) {
        if (m_control_image->GetSize().x > m_panel_image->GetSize().x)
            frame_size.x += m_control_image->GetSize().x - m_panel_image->GetSize().x;
        frame_size.y += increase.y;
    }

    // m_control_image->Refresh();
    // m_control_image->Update();
    // m_mainpanel->GetSizer()->SetSizeHints(m_mainpanel);

    SetSize(frame_size);
    Thaw();

    Refresh();
}

void FrameMain::OnVideoOpen() {
	if (!context->videoController->IsLoaded()) {
		SetDisplayMode(0, -1);
		return;
	}

	Freeze();
	int vidx = context->videoController->GetWidth(),
		vidy = context->videoController->GetHeight();

	// Set zoom level based on video resolution and window size
	double zoom = context->videoDisplay->GetZoom();
	wxSize windowSize = GetSize();
	if (vidx*3*zoom > windowSize.GetX()*4 || vidy*4*zoom > windowSize.GetY()*6)
		context->videoDisplay->SetZoom(zoom * .25);
	else if (vidx*3*zoom > windowSize.GetX()*2 || vidy*4*zoom > windowSize.GetY()*3)
		context->videoDisplay->SetZoom(zoom * .5);

	SetDisplayMode(1,-1);

	if (OPT_GET("Video/Detached/Enabled")->GetBool() && !context->dialog->Get<DialogDetachedVideo>())
		cmd::call("video/detach", context.get());
	Thaw();

	if (!blockAudioLoad && OPT_GET("Video/Open Audio")->GetBool() && context->audioController->GetAudioURL() != context->videoController->GetVideoName()) {
		try {
			context->audioController->OpenAudio(context->videoController->GetVideoName());
		}
		catch (agi::UserCancelException const&) { }
		// Opening a video with no audio data isn't an error, so just log
		// and move on
		catch (agi::fs::FileSystemError const&) {
			LOG_D("video/open/audio") << "File " << context->videoController->GetVideoName() << " found by video provider but not audio provider";
		}
		catch (agi::AudioDataNotFoundError const& e) {
			LOG_D("video/open/audio") << "File " << context->videoController->GetVideoName() << " has no audio data: " << e.GetChainedMessage();
		}
		catch (agi::AudioOpenError const& err) {
			wxMessageBox(to_wx(err.GetMessage()), "Error loading audio", wxOK | wxICON_ERROR | wxCENTER);
		}
	}
}

void FindSequenceDialog::OnSearch ( wxCommandEvent &ev )
	{
	status->SetLabel ( txt("t_searching") ) ;
	wxBeginBusyCursor() ;
	wxSafeYield() ;
	Freeze () ;
	lb->Clear () ;
	vi.Clear () ;
	if ( cb_sequence && cb_sequence->GetValue() )
       {
       sequenceSearch() ;
       if ( c->def == _T("dna") || c->def == _T("ABIviewer") || c->def == _T("PrimerDesign") ) sequenceSearch ( true ) ;
       }
	//if ( c->def == _T("dna") || c->def == _T("PrimerDesign") ) 
	if ( cb_translation && cb_translation->GetValue() ) aaSearch () ;
	if ( cb_items && cb_items->GetValue() ) itemSearch() ;
	if ( cb_enzymes && cb_enzymes->GetValue() ) restrictionSearch() ;
	if ( !vi.IsEmpty() )
		{
		lb->SetSelection ( 0 ) ;
		OnLB ( ev ) ;
		}

	// Status text
	if ( lb->GetCount() > FIND_MAX )
	    {
		status->SetLabel ( wxString::Format ( txt("t_too_many_search_results") , FIND_MAX ) ) ;
		do_highlight->Enable() ;
        }
	else if ( lb->GetCount() == 0 )
	     {
	     status->SetLabel ( txt("t_no_matches_found") ) ;
         }
	else
	    {
		status->SetLabel ( wxString::Format ( txt("t_matches_found") , lb->GetCount() ) ) ;
		do_highlight->Enable() ;
        }
	
	Thaw () ;
	wxEndBusyCursor() ;
	}

void NyqTextCtrl::OnChar(wxKeyEvent & e)
{
	e.Skip();

   // Hide any previously highlighted parens
   if (mLeftParen >= 0) {
#if defined(__WXMSW__)
      Freeze(); // Prevents selection flashing on Windows
#endif

      SetStyle(mLeftParen, mLeftParen + 1, mOff);
      SetStyle(mLeftParens[mLeftParen], mLeftParens[mLeftParen] + 1, mOff);
      mLeftParen = -1;
      mRightParen = -1;

#if defined(__WXMSW__)
      Thaw(); // Prevents selection flashing on Windows
#endif
   }
}

void ThreadList::fillList()
{
    Freeze();
    for(int i=0; i<(int)threads.size(); ++i)
    {
        char buf[32];
        sprintf(buf, "%d", threads[i].getID());
        this->SetItem(i, COL_ID, buf);

        this->SetItem(i, COL_LOCATION, threads[i].getLocation());

        char str[32];
        if (threads[i].cpuUsage >= 0)
            sprintf(str, "%i%%", threads[i].cpuUsage);
        else
            strcpy(str, "-");
        this->SetItem(i, COL_CPUUSAGE, str);
    }
    Thaw();
}

void MiniStyledTextCtrl::SetMarker()
{

    Freeze();
    MarkerDeleteAll(GetOurMarkerNumber());
    MarkerSetBackground(GetOurMarkerNumber(), backgroundColour_);
    if (inverseMarker_)
    {
        for (int l = visibleFrom; l < visibleFrom+visibleLength ; ++l)
            MarkerAdd(l, GetOurMarkerNumber());
    }
    else
    {
        for (int l = 0; l < visibleFrom ; ++l)
            MarkerAdd(l, GetOurMarkerNumber());
        for (int l = visibleFrom+visibleLength; l < GetLineCount() ; ++l)
            MarkerAdd(l, GetOurMarkerNumber());
    }
    Thaw();
}

void main_gui::trainwin::Redraw() {
	Freeze();
	grid->BeginBatch();
	if (grid->GetNumberRows()) {
		grid->DeleteRows(0, grid->GetNumberRows());
	}

	w->EnumerateTrains([&](const train &t) {
		grid->AppendRows(1);
		int rowid = grid->GetNumberRows() - 1;
		grid->SetRowLabelValue(rowid, wxT(""));
		int colid = 0;
		for (auto &it : columns->columns) {
			grid->SetCellValue(rowid, colid++, wxstrstd(it.func(t)));
		}
	});

	grid->EndBatch();
	Thaw();
}