// ----------------------------------------------------------------------------
bool ThreadSearchFrame::OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& files)
// ----------------------------------------------------------------------------
{
bool success = true; // Safe case initialisation
// first check to see if a workspace is passed. If so, only this will be loaded
wxString foundWorkspace;
for (unsigned int i = 0; i < files.GetCount(); ++i)
{
FileType ft = FileTypeOf(files[i]);
if (ft == ftCodeBlocksWorkspace || ft == ftMSVC6Workspace || ft == ftMSVC7Workspace)
{
foundWorkspace = files[i];
break;
}
}
if (!foundWorkspace.IsEmpty())
success &= OpenGeneric(foundWorkspace);
else
{
wxBusyCursor useless;
wxPaintEvent e;
ProcessEvent(e);
Freeze();
for (unsigned int i = 0; i < files.GetCount(); ++i)
success &= OpenGeneric(files[i]);
Thaw();
}
return success;
}
void wxFoldPanelBar::RefreshPanelsFrom(size_t i)
{
Freeze();
// if collapse to bottom is on, the panels that are not expanded
// should be drawn at the bottom. All panels that are expanded
// are drawn on top. The last expanded panel gets all the extra space
if(m_extraStyle & wxFPB_COLLAPSE_TO_BOTTOM)
{
int offset = 0;
for(size_t j = 0; j < m_panels.GetCount(); j++)
{
if(m_panels.Item(j)->IsExpanded())
offset += m_panels.Item(j)->Reposition(offset);
}
// put all non collapsed panels at the bottom where there is space, else
// put them right behind the expanded ones
RepositionCollapsedToBottom();
}
else
{
int pos = m_panels.Item(i)->GetItemPos() + m_panels.Item(i)->GetPanelLength();
for(i++; i < m_panels.GetCount(); i++)
pos += m_panels.Item(i)->Reposition(pos);
}
Thaw();
}
void DiffPanel::OnButtonSwap(wxCommandEvent& WXUNUSED(event)) {
m_mainSizer->Detach(m_leftEditor);
m_mainSizer->Detach(m_rightEditor);
EditorCtrl* temp = m_leftEditor;
m_leftEditor = m_rightEditor;
m_rightEditor = temp;
m_mainSizer->Add(m_leftEditor, wxGBPosition(1,1), wxGBSpan(1,1), wxEXPAND);
m_mainSizer->Add(m_rightEditor, wxGBPosition(1,3), wxGBSpan(1,1), wxEXPAND);
m_leftEditor->SetScrollbarLeft(true);
m_rightEditor->SetScrollbarLeft(false);
m_leftEditor->SetGutterRight(false);
m_rightEditor->SetGutterRight(true);
m_leftMarkBar->SetEditor(m_leftEditor);
m_rightMarkBar->SetEditor(m_rightEditor);
m_diffBar->Swap();
Freeze();
m_leftTitle->SetValue(m_leftEditor->GetPath());
m_rightTitle->SetValue(m_rightEditor->GetPath());
m_mainSizer->Layout();
m_leftEditor->ReDraw();
m_rightEditor->ReDraw();
Thaw();
}
void ConfigurationManagerDlg::PopulateConfigurations()
{
//popuplate the configurations
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
if (!matrix) {
return;
}
wxFlexGridSizer *mainSizer = dynamic_cast<wxFlexGridSizer*>(m_scrolledWindow->GetSizer());
if (!mainSizer) return;
Freeze();
// remove old entries from the configuration table
wxSizerItemList list = mainSizer->GetChildren();
for ( wxSizerItemList::Node *node = list.GetFirst(); node; node = node->GetNext() ) {
wxSizerItem *current = node->GetData();
current->GetWindow()->Destroy();
}
m_projSettingsMap.clear();
std::list<CSolitionConfigurationPtr> configs = matrix->GetConfigurations();
std::list<CSolitionConfigurationPtr>::iterator iter = configs.begin();
m_choiceConfigurations->Clear();
for (; iter != configs.end(); iter++) {
m_choiceConfigurations->Append((*iter)->GetName());
}
// append the 'New' & 'Delete' commands
m_choiceConfigurations->Append(clCMD_NEW);
m_choiceConfigurations->Append(clCMD_EDIT);
int sel = m_choiceConfigurations->FindString(matrix->GetSelectedConfigurationName());
if (sel != wxNOT_FOUND) {
m_choiceConfigurations->SetSelection(sel);
} else if (m_choiceConfigurations->GetCount() > 2) {
m_choiceConfigurations->SetSelection(2);
} else {
m_choiceConfigurations->Append(wxT("Debug"));
m_choiceConfigurations->SetSelection(2);
}
// keep the current workspace configuration
m_currentWorkspaceConfiguration = m_choiceConfigurations->GetStringSelection();
wxArrayString projects;
ManagerST::Get()->GetProjectList(projects);
projects.Sort(wxStringCmpFunc);
for (size_t i=0; i<projects.GetCount(); i++) {
wxString selConf = matrix->GetProjectSelectedConf(matrix->GetSelectedConfigurationName(), projects.Item(i));
AddEntry(projects.Item(i), selConf);
}
Thaw();
mainSizer->Fit(m_scrolledWindow);
Layout();
}
//---------------------------------------------------------
void CData_Source_PgSQL::Update_Source(const wxTreeItemId &Item)
{
CData_Source_PgSQL_Data *pData = Item.IsOk() ? (CData_Source_PgSQL_Data *)GetItemData(Item) : NULL; if( pData == NULL ) return;
if( pData->Get_Type() != TYPE_SOURCE )
{
return;
}
Freeze();
DeleteChildren(Item);
//-----------------------------------------------------
if( !pData->is_Connected() )
{
SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Normal);
SetItemImage(Item, IMG_SRC_CLOSED, wxTreeItemIcon_Selected);
}
else
{
SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Normal);
SetItemImage(Item, IMG_SRC_OPENED, wxTreeItemIcon_Selected);
CSG_Table Tables;
RUN_MODULE(DB_PGSQL_Table_List, false, // CTable_List
SET_PARAMETER("CONNECTION", pData->Get_Value())
&& SET_PARAMETER("TABLES" , &Tables)
);
Tables.Set_Index(1, TABLE_INDEX_Ascending, 0, TABLE_INDEX_Ascending);
for(int i=0; i<Tables.Get_Count(); i++)
{
CSG_String s(Tables[i].asString(1));
TSG_Shape_Type Shape;
TSG_Vertex_Type Vertex;
if( CSG_Shapes_OGIS_Converter::to_ShapeType(s, Shape, Vertex) )
{
switch( Shape )
{
case SHAPE_TYPE_Point: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINT ); break;
case SHAPE_TYPE_Points: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POINTS ); break;
case SHAPE_TYPE_Line: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_LINE ); break;
case SHAPE_TYPE_Polygon: Append_Table(Item, Tables[i].asString(0), TYPE_SHAPES, IMG_POLYGON); break;
}
}
else if( !s.Cmp("RASTER" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_GRIDS , IMG_GRIDS );
else if( !s.Cmp("TABLE" ) ) Append_Table(Item, Tables[i].asString(0), TYPE_TABLE , IMG_TABLE );
}
Expand(Item);
}
Thaw();
}
void ReloadPreviews()
{
Freeze();
m_ScrolledPanel->DestroyChildren();
m_ItemSizer->Clear();
m_LastTerrainSelection = NULL; // clear any reference to deleted button
AtlasMessage::qGetTerrainGroupPreviews qry((std::wstring)m_Name.wc_str(), imageWidth, imageHeight);
qry.Post();
std::vector<AtlasMessage::sTerrainTexturePreview> previews = *qry.previews;
bool allLoaded = true;
for (size_t i = 0; i < previews.size(); ++i)
{
if (!previews[i].loaded)
allLoaded = false;
wxString name = previews[i].name.c_str();
// Construct the wrapped-text label
wxStaticText* label = new wxStaticText(m_ScrolledPanel, wxID_ANY, FormatTextureName(name), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER);
label->Wrap(imageWidth);
unsigned char* buf = (unsigned char*)(malloc(previews[i].imageData.GetSize()));
// imagedata.GetBuffer() gives a Shareable<unsigned char>*, which
// is stored the same as a unsigned char*, so we can just copy it.
memcpy(buf, previews[i].imageData.GetBuffer(), previews[i].imageData.GetSize());
wxImage img (imageWidth, imageHeight, buf);
wxButton* button = new wxBitmapButton(m_ScrolledPanel, wxID_ANY, wxBitmap(img));
// Store the texture name in the clientdata slot
button->SetClientObject(new wxStringClientData(name));
wxSizer* imageSizer = new wxBoxSizer(wxVERTICAL);
imageSizer->Add(button, wxSizerFlags().Center());
imageSizer->Add(label, wxSizerFlags().Proportion(1).Center());
m_ItemSizer->Add(imageSizer, wxSizerFlags().Expand().Center());
}
m_ScrolledPanel->Fit();
Layout();
Thaw();
// If not all textures were loaded yet, run a timer to reload the previews
// every so often until they've all finished
if (allLoaded && m_Timer.IsRunning())
{
m_Timer.Stop();
}
else if (!allLoaded && !m_Timer.IsRunning())
{
m_Timer.Start(2000);
}
}
void Frame::OnInsertPage(wxCommandEvent& WXUNUSED(event))
{
size_t index = book->GetSelection();
Freeze();
bool ret = InsertNotebookPage((long)index);
wxUnusedVar(ret);
Thaw();
}
bool wxFlatNotebook::InsertPage(size_t index, wxWindow* page, const wxString& text, bool select, const int imgindex)
{
// sanity check
if (!page)
return false;
// reparent the window to us
page->Reparent(this);
if( !m_pages->IsShown() )
m_pages->Show();
index = FNB_MIN((unsigned int)index, (unsigned int)m_windows.GetCount());
// Insert tab
bool bSelected = select || m_windows.empty();
int curSel = m_pages->GetSelection();
if(index <= m_windows.GetCount())
{
m_windows.Insert(page, index);
wxLogTrace(wxTraceMask(), wxT("New page inserted. Index = %i"), index);
}
else
{
m_windows.Add(page);
wxLogTrace(wxTraceMask(), wxT("New page appended. Index = %i"), index);
}
if( !m_pages->InsertPage(index, page, text, bSelected, imgindex) )
return false;
if((int)index <= curSel) curSel++;
Freeze();
// Check if a new selection was made
if(bSelected)
{
if(curSel >= 0)
{
// Remove the window from the main sizer
m_mainSizer->Detach(m_windows[curSel]);
m_windows[curSel]->Hide();
}
m_pages->SetSelection(index);
}
else
{
// Hide the page
page->Hide();
}
m_mainSizer->Layout();
Thaw();
Refresh();
return true;
}
void Frame::OnAddPage(wxCommandEvent& WXUNUSED(event))
{
wxString caption;
caption.Printf(wxT("New Page Added #%ld"), newPageCounter);
Freeze();
book->AddPage(CreatePage(), caption, true, m_bShowImages ? rand() % (int)book->GetImageList()->size() : -1);
Thaw();
}
void BFBackupTree::RefreshPlaceholders ()
{
Freeze ();
// only refresh filled placeholders!
if ( GetFillBlackfiskPlaceholders() )
{
VectorTreeItemId vecIdsDate;
VectorTreeItemId vecIdsTime;
VectorTreeItemId vecIdsAll;
// find all items with a label matching to the old filled placeholders
if ( !(BFCore::Instance().GetDateString_Old().IsEmpty()) )
vecIdsDate = FindItems (GetRootItem(), BF_BACKUPTREE_FILLED_DATE_MASK);
if ( !(BFCore::Instance().GetTimeString_Old().IsEmpty()) )
vecIdsTime = FindItems (GetRootItem(), BF_BACKUPTREE_FILLED_TIME_MASK);
vecIdsAll.reserve(vecIdsDate.size() + vecIdsTime.size());
vecIdsAll.insert( vecIdsAll.end(), vecIdsDate.begin(), vecIdsDate.end() );
vecIdsAll.insert( vecIdsAll.end(), vecIdsTime.begin(), vecIdsTime.end() );
// are there items to refresh?
if ( !(vecIdsAll.empty()) )
{
wxString strPath;
wxString strLabel;
// iterate on the items
for (ItVectorTreeItemId it = vecIdsAll.begin();
it != vecIdsAll.end();
++it)
{
strPath = GetPathByItem(*it);
while ( strPath.Matches(BF_BACKUPTREE_PLACEHOLDER_MASK)
|| strPath.Matches(BF_BACKUPTREE_PLACEHOLDER_MASK))
{
strLabel = GetItemText(*it);
if ( strLabel.Matches(BF_BACKUPTREE_FILLED_DATE_MASK)
|| strLabel.Matches(BF_BACKUPTREE_FILLED_TIME_MASK))
{
strLabel = strPath.AfterLast(wxFILE_SEP_PATH);
SetItemText(*it, BFBackup::FillBlackfiskPlaceholders(strLabel));
}
// cut the last diretory from path
strPath = strPath.BeforeLast(wxFILE_SEP_PATH);
}
}
}
}
Thaw();
}
void CContextControl::CreateTab()
{
wxGetApp().AddStartupProfileRecord(_T("CContextControl::CreateTab"));
Freeze();
CState* pState = 0;
// See if we can reuse an existing context
for (size_t i = 0; i < m_context_controls.size(); i++)
{
if (m_context_controls[i].tab_index != -1)
continue;
if (m_context_controls[i].pState->IsRemoteConnected() ||
!m_context_controls[i].pState->IsRemoteIdle())
continue;
pState = m_context_controls[i].pState;
m_context_controls.erase(m_context_controls.begin() + i);
if (m_current_context_controls > (int)i)
m_current_context_controls--;
break;
}
if (!pState)
{
pState = CContextManager::Get()->CreateState(m_pMainFrame);
if (!pState->CreateEngine())
{
wxMessageBoxEx(_("Failed to initialize FTP engine"));
}
}
// Restore last server and path
CServer last_server;
CServerPath last_path;
if (COptions::Get()->GetLastServer(last_server) && last_path.SetSafePath(COptions::Get()->GetOption(OPTION_LASTSERVERPATH)))
pState->SetLastServer(last_server, last_path);
CreateContextControls(pState);
pState->GetRecursiveOperationHandler()->SetQueue(m_pMainFrame->GetQueue());
wxString localDir = COptions::Get()->GetOption(OPTION_LASTLOCALDIR);
if (!pState->SetLocalDir(localDir))
pState->SetLocalDir(_T("/"));
CContextManager::Get()->SetCurrentContext(pState);
if (!m_pMainFrame->RestoreSplitterPositions())
m_pMainFrame->SetDefaultSplitterPositions();
if (m_tabs)
m_tabs->SetSelection(m_tabs->GetPageCount() - 1);
Thaw();
}
void ReloadBitmaps()
{
Freeze();
InitialiseThemedBitmaps();
for (int i = 0; i < ID_NUM; ++i)
SetToolBitmap(i, m_Bitmaps[i]);
Thaw();
}
void WorkspaceTab::OnProjectRemoved(clCommandEvent& e)
{
e.Skip();
Freeze();
m_fileView->BuildTree();
OnGoHome(e);
Thaw();
DoUpdateChoiceWithProjects();
SendCmdEvent(wxEVT_FILE_VIEW_REFRESHED);
}
void HeadersDetectorDlg::OnTimer1Trigger(wxTimerEvent& /*event*/)
{
wxCriticalSectionLocker lock(m_Section);
Freeze();
m_FileNameTxt->SetLabel( m_FileName );
m_ProgressBar->SetValue( m_Progress );
if ( m_Finished )
EndModal( m_Cancel ? wxID_CANCEL : wxID_OK );
Thaw();
}
void ctlSQLBox::OnPositionStc(wxStyledTextEvent &event)
{
int pos = GetCurrentPos();
wxChar ch = GetCharAt(pos - 1);
int st = GetStyleAt(pos - 1);
int match;
// Line numbers
// Ensure we don't recurse through any paint handlers on Mac
#ifdef __WXMAC__
Freeze();
#endif
UpdateLineNumber();
#ifdef __WXMAC__
Thaw();
#endif
// Clear all highlighting
BraceBadLight(wxSTC_INVALID_POSITION);
// Check for braces that aren't in comment styles,
// double quoted styles or single quoted styles
if ((ch == '{' || ch == '}' ||
ch == '[' || ch == ']' ||
ch == '(' || ch == ')') &&
st != 2 && st != 6 && st != 7)
{
match = BraceMatch(pos - 1);
if (match != wxSTC_INVALID_POSITION)
BraceHighlight(pos - 1, match);
}
// Roll back through the doc and highlight any unmatched braces
while ((pos--) >= 0)
{
ch = GetCharAt(pos);
st = GetStyleAt(pos);
if ((ch == '{' || ch == '}' ||
ch == '[' || ch == ']' ||
ch == '(' || ch == ')') &&
st != 2 && st != 6 && st != 7)
{
match = BraceMatch(pos);
if (match == wxSTC_INVALID_POSITION)
{
BraceBadLight(pos);
break;
}
}
}
event.Skip();
}
void GotoFileList::UpdateList(const bool reloadAll) {
const FileEntry* selEntry = GetSelectedAction();
const int topLine = GetFirstVisibleLine();
int selection = -1;
const unsigned int startItem = reloadAll ? 0 : m_items.size();
// Insert new items
if (m_searchText.empty()) {
// Copy all actions to items
m_items.resize(m_actions.size());
for (unsigned int i = startItem; i < m_actions.size(); ++i) {
m_items[i].file_entry = m_actions[i];
m_items[i].hlChars.clear();
}
}
else {
// Copy matching actions to items
for (unsigned int i = m_actionCount; i < m_actions.size(); ++i) {
if (m_tempEntry->path.empty() || m_actions[i]->path != m_tempEntry->path)
AddFileIfMatching(m_searchText, m_actions[i]);
}
}
// Sort the items
if (startItem) {
sort(m_items.begin() + startItem, m_items.end());
inplace_merge(m_items.begin(), m_items.begin() + startItem, m_items.end());
}
else sort(m_items.begin(), m_items.end());
// Keep same selection
if (selEntry) {
for (unsigned int i = 0; i < m_items.size(); ++i) {
if (m_items[i].file_entry == selEntry) {
selection = i;
break;
}
}
}
// Refresh and redraw listCtrl
Freeze();
SetItemCount(m_items.size());
SetSelection(selection);
if (selection == -1)
ScrollToLine(topLine);
else if (!IsVisible(selection))
ScrollToLine(selection);
RefreshAll();
Thaw();
m_actionCount = m_actions.size();
}
void Frame::OnInsertBeforeGivenPage(wxCommandEvent& WXUNUSED(event))
{
long tabIdx = GetTabIndexFromUser (wxT("Insert Page"), wxT("Enter Tab Number to insert the page before:"));
if (tabIdx != -1)
{
Freeze();
bool ret = InsertNotebookPage(tabIdx);
wxUnusedVar(ret);
Thaw();
}
}
void CBOINCBaseView::InitSort() {
wxListItem item;
if (m_iSortColumn < 0) return;
item.SetMask(wxLIST_MASK_IMAGE);
item.SetImage(m_bReverseSort ? 0 : 1);
m_pListPane->SetColumn(m_iSortColumn, item);
Freeze(); // To reduce flicker
sortData();
Thaw();
}
void SymbolTree::BuildTree(const wxFileName &fileName)
{
// Clear the tree
DeleteAllItems();
m_items.clear();
m_globalsNode = wxTreeItemId();
m_prototypesNode = wxTreeItemId();
m_macrosNode = wxTreeItemId();
m_sortItems.clear();
m_fileName = fileName;
// Get the current tree
m_tree = TagsManagerST::Get()->Load(m_fileName);
if ( !m_tree ) {
return;
}
// Add invisible root node
wxTreeItemId root;
root = AddRoot(fileName.GetFullName(), 15, 15);
TreeWalker<wxString, TagEntry> walker(m_tree->GetRoot());
// add three items here:
// the globals node, the mcros and the prototype node
m_globalsNode = AppendItem(root, wxT("Global Functions and Variables"), 2, 2, new MyTreeItemData(wxT("Global Functions and Variables"), wxEmptyString));
m_prototypesNode = AppendItem(root, wxT("Functions Prototypes"), 2, 2, new MyTreeItemData(wxT("Functions Prototypes"), wxEmptyString));
m_macrosNode = AppendItem(root, wxT("Macros"), 2, 2, new MyTreeItemData(wxT("Macros"), wxEmptyString));
// Iterate over the tree and add items
m_sortItems.clear();
Freeze();
for (; !walker.End(); walker++) {
// Add the item to the tree
TagNode* node = walker.GetNode();
// Skip root node
if (node->IsRoot())
continue;
// Add the node
AddItem(node);
}
SortTree(m_sortItems);
Thaw();
//select the root node by default
if (!(GetWindowStyleFlag() & wxTR_HIDE_ROOT)) {
//root is visible, select it
SelectItem(GetRootItem());
}
}
void CCTestFrame::AppendToLog(const wxString& log)
{
Freeze();
m_LogCtrl->AppendText( wxString::Format(_T("%06d. "), ++m_LogCount) );
m_LogCtrl->AppendText( log );
m_LogCtrl->AppendText( _T("\r\n") );
m_LogCtrl->SetInsertionPoint(m_LogCtrl->GetLastPosition());
Thaw();
}
void MapSidebar::OnCollapse(wxCollapsiblePaneEvent& WXUNUSED(evt))
{
Freeze();
// Toggling the collapsing doesn't seem to update the sidebar layout
// automatically, so do it explicitly here
Layout();
Refresh(); // fixes repaint glitch on Windows
Thaw();
}
void wxFoldPanelItem::ResizePanel()
{
bool vertical = IsVertical();
// prevent unnecessary updates by blocking repaints for a sec
Freeze();
// force this panel to take the width of the parent panel and the y of the
// user or calulated width (which will be recalculated by the contents here
wxSize size;
if(m_captionBar->IsCollapsed())
{
size = m_captionBar->GetSize();
m_panelSize = vertical ? size.GetHeight() : size.GetWidth();
}
else
{
size = GetBestSize();
m_panelSize = vertical ? size.GetHeight() : size.GetWidth();
if(m_userSized)
{
if ( vertical )
size.SetHeight(m_userSize);
else
size.SetWidth(m_userSize);
}
}
wxSize pnlsize = GetParent()->GetSize();
if ( vertical )
size.SetWidth(pnlsize.GetWidth());
else
size.SetHeight(pnlsize.GetHeight());
// resize caption bar
m_captionBar->SetSize( vertical ? size.GetWidth() : wxDefaultCoord,
vertical ? wxDefaultCoord : size.GetHeight());
// resize the panel
SetSize(size);
// go by all the controls and call Layout
for(size_t i = 0; i < m_items.GetCount(); i++)
m_items.Item(i).ResizeItem( vertical ? size.GetWidth() : size.GetHeight() , vertical );
// and draw all
Thaw();
}
void tpanelscrollpane::resizemsghandler(wxCommandEvent &event) {
#if TPANEL_SCROLLING_COPIOUS_LOGGING
LogMsgFormat(LOGT::TPANELTRACE, "TSCL: tpanelscrollpane::resizemsghandler %s", cstr(GetThisName()));
#endif
if (tpanelscrollbar *tsb = get_paired_ptr()) {
tsb->RepositionItems();
}
resize_update_pending = false;
Thaw();
Update();
}
void wxsAdvQPP::Register(wxsAdvQPPChild* Child,const wxString& Title)
{
Freeze();
wxButton* Button = new wxButton(this,-1,_T(" - ") + Title,wxDefaultPosition,wxDefaultSize,wxNO_BORDER|wxBU_EXACTFIT|wxBU_LEFT);
Sizer->Add(Button,0,wxEXPAND,0);
Sizer->Add(Child,0,wxEXPAND,0);
Sizer->SetSizeHints(this);
Sizer->Fit(this);
Layout();
Thaw();
Buttons.Add(Button);
Children.Add(Child);
}
bool CMuleNotebook::DeleteAllPages()
{
Freeze();
bool result = true;
while ( GetPageCount() ) {
result &= DeletePage( 0 );
}
Thaw();
return result;
}
bool Notebook::DeleteAllPages(bool notify)
{
bool res = true;
Freeze();
size_t count = m_tabs->GetTabsCount();
for(size_t i=0; i<count && res; i++){
res = DeletePage(0, notify);
}
Thaw();
return res;
}
void wxSpinTreeCtrl::addToTree(spin::ReferencedNode *n, wxTreeItemId parentID)
{
Freeze();
std::string strLabel = n->nodeType + " : " + n->id->s_name;
wxSpinTreeItemData *treeData = new wxSpinTreeItemData;
treeData->m_pNode = n;
wxTreeItemId id = AppendItem(parentID, wxString(strLabel.c_str(),wxConvUTF8), -1, -1, treeData);
UpdateTreeItemIcon(id);
Thaw();
ExpandAll();
}
void BFBackupTree::UpdateItems (VectorTreeItemId &vec)
{
Freeze();
for (ItVectorTreeItemId it = vec.begin();
it != vec.end();
++it)
{
UpdateItem(*it);
}
Thaw();
}
void Notebook::AddPage(wxWindow *win, const wxString &text, const wxString &tooltip, const wxBitmap &bmp, bool selected)
{
Freeze();
CustomTab *tab = new CustomTab(m_tabs, wxID_ANY, text, tooltip, bmp, selected, m_tabs->GetOrientation(), m_style);
win->Reparent(this);
tab->SetWindow(win);
AddPage(tab);
GetSizer()->Layout();
Thaw();
}
void BundleManager::UpdateBundleList() {
Freeze();
m_bundleList->DeleteAllItems();
// Insert bundles in ListCtrl
for (vector<RepoInfo>::const_iterator p = m_repositories.begin(); p != m_repositories.end(); ++p) {
AddItems(p->name, p->bundleList);
}
m_bundleList->SortItems(CompareNameFunction, 0);
Thaw();
}
