CXBindingsObjectBase *CXBindingsGeneratorFileHandler::DoCreateResource()
{
CXBINDINGS_MAKE_INSTANCE( sfile , CXBindingsGeneratorFile );
std::string name = GetXmlAttr( m_node , "lang") ;
if(name.empty())
CXB_THROW( "GeneratorFile with no lang property") ;
sfile->SetName( name );
CXBindingsArrayGrammarGeneratorFileVar& vars = sfile->GetVariables();
CXBindingsArrayGrammarGeneratorFileAddin& addins = sfile->GetAddins();
CXBindingsArrayGrammarGeneratorFileTemplate& templates = sfile->GetTemplates();
xmlNode* child = m_node->children;
while( child != NULL )
{
std::string cname = cxC2U( (char*) child->name );
if( cname =="var")
{
CXBindingsGeneratorFileVar* object = (CXBindingsGeneratorFileVar*) CreateResFromNode(child,NULL);
if( object != NULL ) {
vars.push_back(*object);
delete object;
}
}
else if( cname =="template")
{
CXBindingsGeneratorFileTemplate* object = (CXBindingsGeneratorFileTemplate*) CreateResFromNode(child,NULL);
if( object != NULL ) {
templates.push_back(*object);
delete object;
}
}
else if( cname =="types_info")
{
CXBindingsGeneratorFileTypeInfo* object = (CXBindingsGeneratorFileTypeInfo*) CreateResFromNode(child,NULL);
if( object != NULL ) {
sfile->SetTypeInfo(*object);
delete object;
}
}
else if( cname =="addin")
{
CXBindingsGeneratorFileAddin* addin = (CXBindingsGeneratorFileAddin*) CreateResFromNode(child,NULL);
if( addin != NULL ) {
addins.push_back(*addin);
delete addin;
}
}
child = child->next;
}
return sfile;
}
CXBindingsObjectBase *CXBindingsRuleHandler::DoCreateResource()
{
CXBINDINGS_MAKE_INSTANCE( rule , CXBindingsRule );
std::string make = GetXmlAttr( m_node , "make") ;
if(!make.empty())
rule->SetMake(make);
std::string accessors = GetXmlAttr( m_node , "accessors") ;
if( !accessors.empty() ){
if( accessors =="true")
rule->SetAccessors(true);
else
rule->SetAccessors(false);
}
xmlNode* child = m_node->children;
while( child != NULL )
{
std::string cname = cxC2U( (char*) child->name );
if( cname =="name")
{
CXBindingsName* name = (CXBindingsName*) CreateResFromNode(child,NULL);
if( name != NULL ) {
rule->SetContentName(*name);
delete name;
}
}
else if( cname =="type")
{
CXBindingsType* type = (CXBindingsType*) CreateResFromNode(child,NULL);
if( type != NULL ) {
rule->SetContentType(*type);
delete type;
}
}
else if( cname =="variable")
{
CXBindingsVariable* var = (CXBindingsVariable*) CreateResFromNode(child,NULL);
if( var != NULL ) {
rule->SetContentVariable(*var);
delete var;
}
}
child = child->next;
}
return rule;
}
CXBindingsObjectBase *CXBindingsForEachChildHandler::DoCreateResource()
{
CXBINDINGS_MAKE_INSTANCE( foreachchild , CXBindingsForEachChild );
std::string of = GetXmlAttr( m_node , "of") ;
if(of.empty())
CXB_THROW( "ForEachChild with no of property") ;
foreachchild->SetOf(of);
CXBindingsArrayGrammarRule& rules = foreachchild->GetRules();
xmlNode* child = m_node->children;
while( child != NULL )
{
std::string cname = cxC2U( (char*) child->name );
if( cname =="rule")
{
CXBindingsRule* rule = (CXBindingsRule*) CreateResFromNode(child,NULL);
if( rule != NULL ) {
rules.push_back(*rule);
delete rule;
}
}
child = child->next;
}
return foreachchild;
}
wxObject *wxBitmapComboBoxXmlHandler::DoCreateResource()
{
if (m_class == wxT("ownerdrawnitem"))
{
if ( !m_combobox )
{
ReportError("ownerdrawnitem only allowed within a wxBitmapComboBox");
return NULL;
}
m_combobox->Append(GetText(wxT("text")),
GetBitmap(wxT("bitmap")));
return m_combobox;
}
else /*if( m_class == wxT("wxBitmapComboBox"))*/
{
// find the selection
long selection = GetLong( wxT("selection"), -1 );
XRC_MAKE_INSTANCE(control, wxBitmapComboBox)
control->Create(m_parentAsWindow,
GetID(),
GetText(wxT("value")),
GetPosition(), GetSize(),
0,
NULL,
GetStyle(),
wxDefaultValidator,
GetName());
m_isInside = true;
m_combobox = control;
wxXmlNode *children_node = GetParamNode(wxT("object"));
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object")))
{
CreateResFromNode(n, control, NULL);
}
n = n->GetNext();
}
m_isInside = false;
m_combobox = NULL;
if (selection != -1)
control->SetSelection(selection);
SetupWindow(control);
return control;
}
}
stdObject* stdXmlReader::Load( const std::string& data ) {
m_doc = xmlParseMemory( data.c_str(), data.size() );
if( m_doc == NULL )
STD_THROW("Error cannot open document!");
m_root = xmlDocGetRootElement( m_doc );
if( m_root == NULL )
STD_THROW("Error cannot get your document root !");
std::string n_root = (char*) m_root->name;
if( n_root.empty() )
STD_THROW( "Error document root is empty" );
/* Once we have extracted the root from the document, we have to
* find a handler which is able to return an object associated to
* this root.
*/
stdObject* resource = CreateResFromNode( m_root , stdEmptyString , NULL , NULL );
xmlFreeDoc(m_doc);
return resource;
}
wxObject *wxSplitterWindowXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(splitter, wxSplitterWindow);
splitter->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxSP_3D),
GetName());
SetupWindow(splitter);
long sashpos = GetLong(wxT("sashpos"), 0);
long minpanesize = GetLong(wxT("minsize"), -1);
if (minpanesize != -1)
splitter->SetMinimumPaneSize(minpanesize);
wxWindow *win1 = NULL, *win2 = NULL;
wxXmlNode *n = m_node->GetChildren();
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object") ||
n->GetName() == wxT("object_ref")))
{
wxObject *created = CreateResFromNode(n, splitter, NULL);
wxWindow *win = wxDynamicCast(created, wxWindow);
if (win1 == NULL)
{
win1 = win;
}
else
{
win2 = win;
break;
}
}
n = n->GetNext();
}
if (win1 == NULL)
wxLogError(wxT("wxSplitterWindow node must contain at least one window."));
bool horizontal = (GetParamValue(wxT("orientation")) != wxT("vertical"));
if (win1 && win2)
{
if (horizontal)
splitter->SplitHorizontally(win1, win2, sashpos);
else
splitter->SplitVertically(win1, win2, sashpos);
}
else
{
splitter->Initialize(win1);
}
return splitter;
}
wxObject *wxSimplebookXmlHandler::DoCreateResource()
{
if (m_class == wxS("simplebookpage"))
{
wxXmlNode *n = GetParamNode(wxS("object"));
if ( !n )
n = GetParamNode(wxS("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_simplebook, NULL);
m_isInside = old_ins;
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (wnd)
{
m_simplebook->AddPage(wnd, GetText(wxS("label")),
GetBool(wxS("selected")));
}
else
{
ReportError(n, "simplebookpage child must be a window");
}
return wnd;
}
else
{
ReportError("simplebookpage must have a window child");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(sb, wxSimplebook)
sb->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxS("style")),
GetName());
SetupWindow(sb);
wxSimplebook *old_par = m_simplebook;
m_simplebook = sb;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_simplebook, true/*only this handler*/);
m_isInside = old_ins;
m_simplebook = old_par;
return sb;
}
}
wxObject *wxCollapsiblePaneXmlHandler::DoCreateResource()
{
if (m_class == wxT("panewindow")) // read the XRC for the pane window
{
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_collpane->GetPane(), NULL);
m_isInside = old_ins;
return item;
}
else
{
ReportError("no control within panewindow");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(ctrl, wxCollapsiblePane)
wxString label = GetText(wxT("label"));
if (label.empty())
{
ReportParamError("label", "label cannot be empty");
return NULL;
}
ctrl->Create(m_parentAsWindow,
GetID(),
label,
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxCP_DEFAULT_STYLE),
wxDefaultValidator,
GetName());
ctrl->Collapse(GetBool(wxT("collapsed")));
SetupWindow(ctrl);
wxCollapsiblePane *old_par = m_collpane;
m_collpane = ctrl;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_collpane, true/*only this handler*/);
m_isInside = old_ins;
m_collpane = old_par;
return ctrl;
}
}
wxObject * MaxBitmapComboBoxXmlHandler::DoCreateResource()
{
if (m_class == wxT("ownerdrawnitem"))
{
wxCHECK_MSG(m_combobox, NULL, wxT("Incorrect syntax of XRC resource: ownerdrawnitem not within a bitmapcombobox!"));
m_combobox->Append(GetText(wxT("text")), GetBitmap(wxT("bitmap"), wxART_MISSING_IMAGE));
return m_combobox;
}
else /*if( m_class == wxT("wxBitmapComboBox"))*/
{
// find the selection
long selection = GetLong( wxT("selection"), -1 );
XRC_MAKE_INSTANCE(control, MaxBitmapComboBox)
control->Create(m_parentAsWindow,
GetID(),
GetText(wxT("value")),
GetPosition(), GetSize(),
0,
NULL,
GetStyle(),
wxDefaultValidator,
GetName());
control->MaxBind(_wx_wxbitmapcombobox_wxBitmapComboBox__xrcNew(control));
m_isInside = true;
m_combobox = control;
wxXmlNode *children_node = GetParamNode(wxT("object"));
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object")))
{
CreateResFromNode(n, control, NULL);
}
n = n->GetNext();
}
m_isInside = false;
m_combobox = NULL;
if (selection != -1)
control->SetSelection(selection);
SetupWindow(control);
return control;
}
}
wxObject *wxStdDialogButtonSizerXmlHandler::DoCreateResource()
{
if (m_class == wxT("wxStdDialogButtonSizer"))
{
wxASSERT( !m_parentSizer );
wxSizer *s = m_parentSizer = new wxStdDialogButtonSizer;
m_isInside = true;
CreateChildren(m_parent, true/*only this handler*/);
m_parentSizer->Realize();
m_isInside = false;
m_parentSizer = NULL;
return s;
}
else // m_class == "button"
{
wxASSERT( m_parentSizer );
// find the item to be managed by this sizeritem
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
// did we find one?
if (n)
{
wxObject *item = CreateResFromNode(n, m_parent, NULL);
wxButton *button = wxDynamicCast(item, wxButton);
if (button)
m_parentSizer->AddButton(button);
else
ReportError(n, "expected wxButton");
return item;
}
else /*n == NULL*/
{
ReportError("no button within wxStdDialogButtonSizer");
return NULL;
}
}
}
wxObject* wxSizerXmlHandler::Handle_sizeritem()
{
// find the item to be managed by this sizeritem
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
// did we find one?
if (n)
{
// create a sizer item for it
wxSizerItem* sitem = MakeSizerItem();
// now fetch the item to be managed
bool old_gbs = m_isGBS;
bool old_ins = m_isInside;
wxSizer *old_par = m_parentSizer;
m_isInside = false;
if (!IsSizerNode(n)) m_parentSizer = NULL;
wxObject *item = CreateResFromNode(n, m_parent, NULL);
m_isInside = old_ins;
m_parentSizer = old_par;
m_isGBS = old_gbs;
// and figure out what type it is
wxSizer *sizer = wxDynamicCast(item, wxSizer);
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (sizer)
sitem->AssignSizer(sizer);
else if (wnd)
sitem->AssignWindow(wnd);
else
ReportError(n, "unexpected item in sizer");
// finally, set other wxSizerItem attributes
SetSizerItemAttributes(sitem);
AddSizerItem(sitem);
return item;
}
else /*n == NULL*/
{
ReportError("no window/sizer/spacer within sizeritem object");
return NULL;
}
}
wxObject* MyWxSimplebookXmlHandler::DoCreateResource()
{
if(m_class == wxT("simplebookpage")) {
wxXmlNode* n = GetParamNode(wxT("object"));
if(!n) n = GetParamNode(wxT("object_ref"));
if(n) {
bool old_ins = m_isInside;
m_isInside = false;
wxObject* item = CreateResFromNode(n, m_notebook, NULL);
m_isInside = old_ins;
wxWindow* wnd = wxDynamicCast(item, wxWindow);
if(wnd) {
m_notebook->AddPage(wnd, GetText(wxT("label")), GetBool(wxT("selected")), wxNOT_FOUND);
} else
wxLogError(wxT("Error in resource."));
return wnd;
} else {
wxLogError(wxT("Error in resource: no control within notebook's <page> tag."));
return NULL;
}
}
else {
wxSimplebook* nb =
new wxSimplebook(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle(wxT("style")));
wxString showEffect = GetText("effect", false);
nb->SetEffect(wxCrafter::ShowEffectFromString(showEffect));
nb->SetName(GetName());
SetupWindow(nb);
wxSimplebook* old_par = m_notebook;
m_notebook = nb;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_notebook, true /*only this handler*/);
m_isInside = old_ins;
m_notebook = old_par;
return nb;
}
}
wxObject *wxAuiToolBarXmlHandler::DoCreateResource()
{
if (m_class == wxS("tool"))
{
if ( !m_toolbar )
{
ReportError("tool only allowed inside a wxAuiToolBar");
return NULL;
}
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(wxS("radio")))
kind = wxITEM_RADIO;
if (GetBool(wxS("toggle")))
{
if ( kind != wxITEM_NORMAL )
{
ReportParamError
(
"toggle",
"tool can't have both <radio> and <toggle> properties"
);
}
kind = wxITEM_CHECK;
}
#if wxUSE_MENUS
// check whether we have dropdown tag inside
wxMenu *menu = NULL; // menu for drop down items
wxXmlNode * const nodeDropdown = GetParamNode("dropdown");
if ( nodeDropdown )
{
// also check for the menu specified inside dropdown (it is
// optional and may be absent for e.g. dynamically-created
// menus)
wxXmlNode * const nodeMenu = GetNodeChildren(nodeDropdown);
if ( nodeMenu )
{
wxObject *res = CreateResFromNode(nodeMenu, NULL);
menu = wxDynamicCast(res, wxMenu);
if ( !menu )
{
ReportError
(
nodeMenu,
"drop-down tool contents can only be a wxMenu"
);
}
if ( GetNodeNext(nodeMenu) )
{
ReportError
(
GetNodeNext(nodeMenu),
"unexpected extra contents under drop-down tool"
);
}
}
}
#endif
wxAuiToolBarItem * const tool =
m_toolbar->AddTool
(
GetID(),
GetText(wxS("label")),
GetBitmap(wxS("bitmap"), wxART_TOOLBAR, m_toolSize),
GetBitmap(wxS("bitmap2"), wxART_TOOLBAR, m_toolSize),
kind,
GetText(wxS("tooltip")),
GetText(wxS("longhelp")),
NULL
);
if ( GetBool(wxS("disabled")) )
m_toolbar->EnableTool(GetID(), false);
#if wxUSE_MENUS
if (menu)
{
tool->SetHasDropDown(true);
tool->SetUserData(m_menuHandler.RegisterMenu(m_toolbar, GetID(), menu));
}
#endif
return m_toolbar; // must return non-NULL
}
else if (m_class == wxS("separator") || m_class == wxS("space") || m_class == wxS("label"))
{
if ( !m_toolbar )
{
ReportError("separators only allowed inside wxAuiToolBar");
return NULL;
}
if ( m_class == wxS("separator") )
m_toolbar->AddSeparator();
else if (m_class == wxS("space"))
{
// This may be a stretch spacer (the default) or a non-stretch one
bool hasProportion = HasParam(wxS("proportion"));
bool hasWidth = HasParam(wxS("width"));
if (hasProportion && hasWidth)
{
ReportError("A space can't both stretch and have width");
return NULL;
}
if (hasWidth)
{
m_toolbar->AddSpacer
(
GetLong(wxS("width"))
);
}
else
{
m_toolbar->AddStretchSpacer
(
GetLong(wxS("proportion"), 1l)
);
}
}
else if (m_class == wxS("label"))
{
m_toolbar->AddLabel
(
GetID(),
GetText(wxS("label")),
GetLong(wxS("width"), -1l)
);
}
return m_toolbar; // must return non-NULL
}
else /*<object class="wxAuiToolBar">*/
{
int style = GetStyle(wxS("style"), wxNO_BORDER | wxTB_HORIZONTAL);
#ifdef __WXMSW__
if (!(style & wxNO_BORDER)) style |= wxNO_BORDER;
#endif
XRC_MAKE_INSTANCE(toolbar, wxAuiToolBar)
toolbar->Create(m_parentAsWindow,
GetID(),
GetPosition(),
GetSize(),
style);
toolbar->SetName(GetName());
SetupWindow(toolbar);
m_toolSize = GetSize(wxS("bitmapsize"));
if (!(m_toolSize == wxDefaultSize))
toolbar->SetToolBitmapSize(m_toolSize);
wxSize margins = GetSize(wxS("margins"));
if (!(margins == wxDefaultSize))
toolbar->SetMargins(margins.x, margins.y);
long packing = GetLong(wxS("packing"), -1);
if (packing != -1)
toolbar->SetToolPacking(packing);
long separation = GetLong(wxS("separation"), -1);
if (separation != -1)
toolbar->SetToolSeparation(separation);
wxXmlNode *children_node = GetParamNode(wxS("object"));
if (!children_node)
children_node = GetParamNode(wxS("object_ref"));
if (children_node == NULL) return toolbar;
m_isInside = true;
m_toolbar = toolbar;
wxXmlNode *n = children_node;
while (n)
{
if (IsObjectNode(n))
{
wxObject *created = CreateResFromNode(n, toolbar, NULL);
wxControl *control = wxDynamicCast(created, wxControl);
if (!IsOfClass(n, wxS("tool")) &&
!IsOfClass(n, wxS("separator")) &&
!IsOfClass(n, wxS("label")) &&
!IsOfClass(n, wxS("space")) &&
control != NULL)
toolbar->AddControl(control);
}
n = GetNodeNext(n);
}
m_isInside = false;
m_toolbar = NULL;
toolbar->Realize();
return toolbar;
}
}
wxObject *wxNotebookXmlHandler::DoCreateResource()
{
if (m_class == wxT("notebookpage"))
{
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_notebook, NULL);
m_isInside = old_ins;
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (wnd)
{
m_notebook->AddPage(wnd, GetText(wxT("label")),
GetBool(wxT("selected")));
if ( HasParam(wxT("bitmap")) )
{
wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER);
wxImageList *imgList = m_notebook->GetImageList();
if ( imgList == NULL )
{
imgList = new wxImageList( bmp.GetWidth(), bmp.GetHeight() );
m_notebook->AssignImageList( imgList );
}
int imgIndex = imgList->Add(bmp);
m_notebook->SetPageImage(m_notebook->GetPageCount()-1, imgIndex );
}
}
else
wxLogError(wxT("Error in resource."));
return wnd;
}
else
{
wxLogError(wxT("Error in resource: no control within notebook's <page> tag."));
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(nb, wxNotebook)
nb->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style")),
GetName());
SetupWindow(nb);
wxNotebook *old_par = m_notebook;
m_notebook = nb;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_notebook, true/*only this handler*/);
m_isInside = old_ins;
m_notebook = old_par;
return nb;
}
}
wxObject *wxTreebookXmlHandler::DoCreateResource()
{
if (m_class == wxT("wxTreebook"))
{
XRC_MAKE_INSTANCE(tbk, wxTreebook)
tbk->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style")),
GetName());
wxTreebook * old_par = m_tbk;
m_tbk = tbk;
bool old_ins = m_isInside;
m_isInside = true;
wxArrayTbkPageIndexes old_treeContext = m_treeContext;
m_treeContext.Clear();
CreateChildren(m_tbk, true/*only this handler*/);
m_treeContext = old_treeContext;
m_isInside = old_ins;
m_tbk = old_par;
return tbk;
}
// else ( m_class == wxT("treebookpage") )
wxXmlNode *n = GetParamNode(wxT("object"));
wxWindow *wnd = NULL;
if ( !n )
n = GetParamNode(wxT("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_tbk, NULL);
m_isInside = old_ins;
wnd = wxDynamicCast(item, wxWindow);
if (wnd == NULL && item != NULL)
wxLogError(wxT("Error in resource: control within treebook's <page> tag is not a window."));
}
size_t depth = GetLong( wxT("depth") );
if( depth <= m_treeContext.Count() )
{
// first prepare the icon
int imgIndex = wxNOT_FOUND;
if ( HasParam(wxT("bitmap")) )
{
wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER);
wxImageList *imgList = m_tbk->GetImageList();
if ( imgList == NULL )
{
imgList = new wxImageList( bmp.GetWidth(), bmp.GetHeight() );
m_tbk->AssignImageList( imgList );
}
imgIndex = imgList->Add(bmp);
}
// then add the page to the corresponding parent
if( depth < m_treeContext.Count() )
m_treeContext.RemoveAt(depth, m_treeContext.Count() - depth );
if( depth == 0)
{
m_tbk->AddPage(wnd,
GetText(wxT("label")), GetBool(wxT("selected")), imgIndex);
}
else
{
m_tbk->InsertSubPage(m_treeContext.Item(depth - 1), wnd,
GetText(wxT("label")), GetBool(wxT("selected")), imgIndex);
}
m_treeContext.Add( m_tbk->GetPageCount() - 1);
}
else
wxLogError(wxT("Error in resource. wxTreebookPage has an invalid depth."));
return wnd;
}
wxObject *wxPropertySheetDialogXmlHandler::DoCreateResource()
{
if (m_class == wxT("propertysheetpage"))
{
wxXmlNode *n = GetParamNode(wxT("object"));
if (!n) n = GetParamNode(wxT("object_ref"));
if (n)
{
wxBookCtrlBase *bookctrl = m_dialog->GetBookCtrl();
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, bookctrl, NULL);
m_isInside = old_ins;
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (wnd)
{
bookctrl->AddPage(wnd, GetText(wxT("label")), GetBool(wxT("selected")));
if (HasParam(wxT("bitmap")))
{
wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER);
wxImageList *imgList = bookctrl->GetImageList();
if (imgList == NULL)
{
imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight());
bookctrl->AssignImageList(imgList);
}
int imgIndex = imgList->Add(bmp);
bookctrl->SetPageImage(bookctrl->GetPageCount()-1, imgIndex);
}
}
else
{
ReportError(n, "propertysheetpage child must be a window");
}
return wnd;
}
else
{
ReportError("propertysheetpage must have a window child");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(dlg, wxPropertySheetDialog)
dlg->Create(m_parentAsWindow,
GetID(),
GetText(wxT("title")),
GetPosition(),
GetSize(),
GetStyle(),
GetName());
if (HasParam(wxT("icon")))
dlg->SetIcons(GetIconBundle(wxT("icon"), wxART_FRAME_ICON));
SetupWindow(dlg);
wxPropertySheetDialog *old_par = m_dialog;
m_dialog = dlg;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_dialog, true/*only this handler*/);
m_isInside = old_ins;
m_dialog = old_par;
if (GetBool(wxT("centered"), false)) dlg->Centre();
wxString buttons = GetText(wxT("buttons"));
if (!buttons.IsEmpty())
{
int flags = 0;
if (buttons.Find(wxT("wxOK")) != wxNOT_FOUND) flags |= wxOK;
if (buttons.Find(wxT("wxCANCEL")) != wxNOT_FOUND) flags |= wxCANCEL;
if (buttons.Find(wxT("wxYES")) != wxNOT_FOUND) flags |= wxYES;
if (buttons.Find(wxT("wxNO")) != wxNOT_FOUND) flags |= wxNO;
if (buttons.Find(wxT("wxHELP")) != wxNOT_FOUND) flags |= wxHELP;
if (buttons.Find(wxT("wxNO_DEFAULT")) != wxNOT_FOUND) flags |= wxNO_DEFAULT;
dlg->CreateButtons(flags);
}
return dlg;
}
}
wxObject *wxChoicebookXmlHandler::DoCreateResource()
{
if (m_class == wxT("choicebookpage"))
{
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_choicebook, NULL);
m_isInside = old_ins;
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (wnd)
{
m_choicebook->AddPage(wnd, GetText(wxT("label")),
GetBool(wxT("selected")));
if ( HasParam(wxT("bitmap")) )
{
wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER);
wxImageList *imgList = m_choicebook->GetImageList();
if ( imgList == NULL )
{
imgList = new wxImageList( bmp.GetWidth(), bmp.GetHeight() );
m_choicebook->AssignImageList( imgList );
}
int imgIndex = imgList->Add(bmp);
m_choicebook->SetPageImage(m_choicebook->GetPageCount()-1, imgIndex );
}
else if ( HasParam(wxT("image")) )
{
if ( m_choicebook->GetImageList() )
{
m_choicebook->SetPageImage(m_choicebook->GetPageCount()-1,
GetLong(wxT("image")) );
}
else // image without image list?
{
ReportError(n, "image can only be used in conjunction "
"with imagelist");
}
}
}
else
{
ReportError(n, "choicebookpage child must be a window");
}
return wnd;
}
else
{
ReportError("choicebookpage must have a window child");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(nb, wxChoicebook)
nb->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style")),
GetName());
wxImageList *imagelist = GetImageList();
if ( imagelist )
nb->AssignImageList(imagelist);
wxChoicebook *old_par = m_choicebook;
m_choicebook = nb;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_choicebook, true/*only this handler*/);
m_isInside = old_ins;
m_choicebook = old_par;
return nb;
}
}
wxObject* wxRibbonXmlHandler::Handle_button()
{
wxRibbonButtonBar *buttonBar = wxStaticCast(m_parent, wxRibbonButtonBar);
wxRibbonButtonKind kind = wxRIBBON_BUTTON_NORMAL;
if (GetBool(wxT("hybrid")))
kind = wxRIBBON_BUTTON_HYBRID;
// FIXME: The code below uses wxXmlNode directly but this can't be done
// in the ribbon library code as it would force it to always link
// with the xml library. Disable it for now but the real solution
// would be to virtualize GetChildren() and GetNext() methods via
// wxXmlResourceHandler, just as we already do for many others.
//
// FIXME: If re-enabling, don't forget to update the docs and RELAG NG schema!
#if 0 // wxUSE_MENUS
// check whether we have dropdown tag inside
wxMenu *menu = NULL; // menu for drop down items
wxXmlNode * const nodeDropdown = GetParamNode("dropdown");
if ( nodeDropdown )
{
if (kind == wxRIBBON_BUTTON_NORMAL)
kind = wxRIBBON_BUTTON_DROPDOWN;
// also check for the menu specified inside dropdown (it is
// optional and may be absent for e.g. dynamically-created
// menus)
wxXmlNode * const nodeMenu = nodeDropdown->GetChildren();
if ( nodeMenu )
{
wxObject *res = CreateResFromNode(nodeMenu, NULL);
menu = wxDynamicCast(res, wxMenu);
if ( !menu )
{
ReportError
(
nodeMenu,
"drop-down tool contents can only be a wxMenu"
);
}
if ( nodeMenu->GetNext() )
{
ReportError
(
nodeMenu->GetNext(),
"unexpected extra contents under drop-down tool"
);
}
}
}
#endif // wxUSE_MENUS
if (!buttonBar->AddButton(GetID(),
GetText("label"),
GetBitmap ("bitmap"),
GetBitmap ("small-bitmap"),
GetBitmap ("disabled-bitmap"),
GetBitmap ("small-disabled-bitmap"),
kind,
GetText("help")))
{
ReportError ("could not create button");
}
if ( GetBool(wxT("disabled")) )
buttonBar->EnableButton(GetID(), false);
return NULL; // nothing to return
}
wxObject *wxToolBarXmlHandlerEx::DoCreateResource()
{
if (m_class == wxT("tool"))
{
if (!m_toolbar)
{
ReportError("tool only allowed inside a wxToolBar");
return NULL;
}
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(wxT("radio")))
kind = wxITEM_RADIO;
if (GetBool(wxT("toggle")))
{
if (kind != wxITEM_NORMAL)
{
ReportParamError
(
"toggle",
"tool can't have both <radio> and <toggle> properties"
);
}
kind = wxITEM_CHECK;
}
#if wxUSE_MENUS
// check whether we have dropdown tag inside
wxMenu *menu = NULL; // menu for drop down items
wxXmlNode * const nodeDropdown = GetParamNode("dropdown");
if (nodeDropdown)
{
if (kind != wxITEM_NORMAL)
{
ReportParamError
(
"dropdown",
"drop-down tool can't have neither <radio> nor <toggle> properties"
);
}
kind = wxITEM_DROPDOWN;
// also check for the menu specified inside dropdown (it is
// optional and may be absent for e.g. dynamically-created
// menus)
wxXmlNode * const nodeMenu = nodeDropdown->GetChildren();
if (nodeMenu)
{
wxObject *res = CreateResFromNode(nodeMenu, NULL);
menu = dynamic_cast<wxMenu*>(res);
if (!menu)
{
ReportError
(
nodeMenu,
"drop-down tool contents can only be a wxMenu"
);
}
if (nodeMenu->GetNext())
{
ReportError
(
nodeMenu->GetNext(),
"unexpected extra contents under drop-down tool"
);
}
}
}
#endif
wxBitmap bitmap = GetBitmap(wxT("bitmap"), wxART_TOOLBAR, m_iconSize);
wxBitmap bitmap2 = GetBitmap(wxT("bitmap2"), wxART_TOOLBAR, m_iconSize);
#ifdef __WXMAC__
if( bitmap.IsOk() ) {
if( bitmap.GetSize().x < 24 ) {
bitmap = wxBitmap(bitmap.ConvertToImage().Size(wxSize(24, 24), wxPoint(4, 4)));
}
}
if( bitmap2.IsOk() ) {
if( bitmap2.GetSize().x < 24 ) {
bitmap2 = wxBitmap(bitmap2.ConvertToImage().Size(wxSize(24, 24), wxPoint(4, 4)));
}
}
#endif
#ifdef __WXGTK3__
// We need to provide a disabled bitmap.
if( !bitmap2.IsOk() && bitmap.IsOk() ) {
bitmap2 = wxBitmap(bitmap.ConvertToImage().ConvertToGreyscale());
}
#endif
wxToolBarToolBase * const tool =
m_toolbar->AddTool
(
GetID(),
GetText(wxT("label")),
bitmap,
bitmap2,
kind,
GetText(wxT("tooltip")),
GetText(wxT("longhelp"))
);
if (GetBool(wxT("disabled")))
m_toolbar->EnableTool(tool->GetId(), false);
if (GetBool(wxS("checked")))
{
if (kind == wxITEM_NORMAL)
{
ReportParamError
(
"checked",
"only <radio> nor <toggle> tools can be checked"
);
}
else
{
m_toolbar->ToggleTool(tool->GetId(), true);
}
}
#if wxUSE_MENUS
if (menu)
tool->SetDropdownMenu(menu);
#endif
return m_toolbar; // must return non-NULL
}
else if (m_class == wxT("separator") || m_class == wxT("space"))
{
if (!m_toolbar)
{
ReportError("separators only allowed inside wxToolBar");
return NULL;
}
if (m_class == wxT("separator"))
m_toolbar->AddSeparator();
else
m_toolbar->AddStretchableSpace();
return m_toolbar; // must return non-NULL
}
else /*<object class="wxToolBar">*/
{
int style = GetStyle(wxT("style"), wxNO_BORDER | wxTB_HORIZONTAL);
#ifdef __WXMSW__
if (!(style & wxNO_BORDER)) style |= wxNO_BORDER;
#endif
XRC_MAKE_INSTANCE(toolbar, wxToolBar)
toolbar->Create(m_parentAsWindow,
GetID(),
GetPosition(),
GetSize(),
style,
GetName());
SetupWindow(toolbar);
toolbar->SetToolBitmapSize(m_iconSize);
wxSize margins = GetSize(wxT("margins"));
if (!(margins == wxDefaultSize))
toolbar->SetMargins(margins.x, margins.y);
long packing = GetLong(wxT("packing"), -1);
if (packing != -1)
toolbar->SetToolPacking(packing);
long separation = GetLong(wxT("separation"), -1);
if (separation != -1)
toolbar->SetToolSeparation(separation);
wxXmlNode *children_node = GetParamNode(wxT("object"));
if (!children_node)
children_node = GetParamNode(wxT("object_ref"));
if (children_node == NULL) return toolbar;
m_isInside = true;
m_toolbar = toolbar;
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object") || n->GetName() == wxT("object_ref")))
{
wxObject *created = CreateResFromNode(n, toolbar, NULL);
wxControl *control = dynamic_cast<wxControl*>(created);
if (!IsOfClass(n, wxT("tool")) &&
!IsOfClass(n, wxT("separator")) &&
!IsOfClass(n, wxT("space")) &&
control != NULL)
toolbar->AddControl(control);
}
n = n->GetNext();
}
m_isInside = false;
m_toolbar = NULL;
if (m_parentAsWindow && !GetBool(wxT("dontattachtoframe")))
{
wxFrame *parentFrame = dynamic_cast<wxFrame*>(m_parent);
if (parentFrame)
parentFrame->SetToolBar(toolbar);
}
toolbar->Realize();
return toolbar;
}
}
CXBindingsObjectBase *CXBindingsChildHandler::DoCreateResource()
{
CXBINDINGS_MAKE_INSTANCE( child , CXBindingsChild );
std::string name = GetXmlAttr( m_node , "name") ;
if(name.empty())
CXB_THROW( "Child with no name property") ;
child->SetName(name);
std::string minOccurs = GetXmlAttr( m_node , "name") ;
long minOccs;
if(minOccurs.empty())
minOccs = 1;
else{
std::stringstream strm;
strm << minOccs;
strm >> minOccurs;
}
child->SetMinOccurs((int) minOccs);
std::string maxOccurs = GetXmlAttr( m_node , "name") ;
long maxOccs;
if(maxOccurs.empty())
maxOccs = 1;
else if( maxOccurs == "unbounded")
maxOccs = -1;
else{
std::stringstream strm;
strm << maxOccs;
strm >> maxOccurs;
}
child->SetMaxOccurs((int) maxOccs);
CXBindingsArrayGrammarProperty& properties = child->GetProperties();
CXBindingsArrayGrammarRule& rules = child->GetRules();
xmlNode* childnode = m_node->children;
while( childnode != NULL )
{
std::string cname = cxC2U( (char*) childnode->name );
if( cname =="rule")
{
CXBindingsRule* rule = (CXBindingsRule*) CreateResFromNode(childnode,NULL);
if( rule != NULL ) {
rules.push_back(*rule);
delete rule;
}
}
else if( cname =="property")
{
CXBindingsProperty* property = (CXBindingsProperty*) CreateResFromNode(childnode,NULL);
if( property != NULL ) {
properties.push_back(*property);
delete property;
}
}
childnode = childnode->next;
}
return child;
}
wxObject* MYwxTreebookXmlHandler::DoCreateResource()
{
if(m_class == wxT("wxTreebook")) {
XRC_MAKE_INSTANCE(tbk, wxTreebook)
tbk->Create(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle(wxT("style")), GetName());
wxTreebook* old_par = m_tbk;
m_tbk = tbk;
bool old_ins = m_isInside;
m_isInside = true;
wxArrayTbkPageIndexes old_treeContext = m_treeContext;
m_treeContext.Clear();
CreateChildren(m_tbk, true /*only this handler*/);
wxXmlNode* node = GetParamNode(wxT("object"));
int pageIndex = 0;
for(unsigned int i = 0; i < m_tbk->GetPageCount(); i++) {
if(m_tbk->GetPage(i)) {
wxXmlNode* child = node->GetChildren();
while(child) {
if(child->GetName() == wxT("expanded") && child->GetNodeContent() == wxT("1"))
m_tbk->ExpandNode(pageIndex, true);
child = child->GetNext();
}
pageIndex++;
}
}
m_treeContext = old_treeContext;
m_isInside = old_ins;
m_tbk = old_par;
return tbk;
}
// else ( m_class == wxT("treebookpage") )
wxXmlNode* n = GetParamNode(wxT("object"));
wxWindow* wnd = NULL;
if(!n) n = GetParamNode(wxT("object_ref"));
if(n) {
bool old_ins = m_isInside;
m_isInside = false;
wxObject* item = CreateResFromNode(n, m_tbk, NULL);
m_isInside = old_ins;
wnd = wxDynamicCast(item, wxWindow);
}
size_t depth = GetLong(wxT("depth"));
if(depth <= m_treeContext.GetCount()) {
// first prepare the icon
int imgIndex = wxNOT_FOUND;
if(HasParam(wxT("bitmap"))) {
wxBitmap bmp = GetBitmap(wxT("bitmap"), wxART_OTHER);
wxImageList* imgList = m_tbk->GetImageList();
if(imgList == NULL) {
imgList = new wxImageList(bmp.GetWidth(), bmp.GetHeight());
m_tbk->AssignImageList(imgList);
}
imgIndex = imgList->Add(bmp);
} else if(HasParam(wxT("image"))) {
if(m_tbk->GetImageList()) {
imgIndex = GetLong(wxT("image"));
} else // image without image list?
{
}
}
// then add the page to the corresponding parent
if(depth < m_treeContext.GetCount()) m_treeContext.RemoveAt(depth, m_treeContext.GetCount() - depth);
if(depth == 0) {
m_tbk->AddPage(wnd, GetText(wxT("label")), GetBool(wxT("selected")), imgIndex);
} else {
m_tbk->InsertSubPage(m_treeContext.Item(depth - 1), wnd, GetText(wxT("label")), GetBool(wxT("selected")),
imgIndex);
}
m_treeContext.Add(m_tbk->GetPageCount() - 1);
} else {
// ReportParamError("depth", "invalid depth");
}
return wnd;
}
wxObject *wxAuiNotebookXmlHandler::DoCreateResource()
{
if (m_class == wxT("notebookpage"))
{
wxXmlNode *anb = GetParamNode(wxT("object"));
if (!anb)
anb = GetParamNode(wxT("object_ref"));
if (anb)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(anb, m_notebook, NULL);
m_isInside = old_ins;
wxWindow *wnd = wxDynamicCast(item, wxWindow);
if (wnd)
{
if ( HasParam(wxT("bitmap")) )
{
m_notebook->AddPage(wnd,
GetText(wxT("label")),
GetBool(wxT("selected")),
GetBitmap(wxT("bitmap"), wxART_OTHER));
}
else
{
m_notebook->AddPage(wnd,
GetText(wxT("label")),
GetBool(wxT("selected")));
}
}
else
{
ReportError(anb, "notebookpage child must be a window");
}
return wnd;
}
else
{
ReportError("notebookpage must have a window child");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(anb, wxAuiNotebook)
anb->Create(m_parentAsWindow,
GetID(),
GetPosition(),
GetSize(),
GetStyle(wxT("style")));
SetupWindow(anb);
wxAuiNotebook *old_par = m_notebook;
m_notebook = anb;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_notebook, true/*only this handler*/);
m_isInside = old_ins;
m_notebook = old_par;
return anb;
}
}
CXBindingsObjectBase *CXBindingsObjectHandler::DoCreateResource()
{
CXBINDINGS_MAKE_INSTANCE( object , CXBindingsObject );
std::string name = GetXmlAttr( m_node , "type") ;
if(name.empty())
CXB_THROW( "Object with no type property") ;
object->SetName(name);
CXBindingsArrayGrammarChild& childs = object->GetChilds();
CXBindingsArrayGrammarProperty& properties = object->GetProperties();
CXBindingsArrayGrammarRule& rules = object->GetRules();
CXBindingsArrayGrammarForEachChild& childRules = object->GetChildRules();
CXBindingsArrayGrammarCategory& categories = object->GetCategories();
CXBindingsArrayGrammarChildContainer& childcontainers = object->GetChildContainers();
CXBindingsArrayGrammarInherits& inherits = object->GetModels();
xmlNode* child = m_node->children;
while( child != NULL )
{
std::string cname = cxC2U( (char*) child->name );
if( cname =="child")
{
CXBindingsChild* child_object = (CXBindingsChild*) CreateResFromNode(child,NULL);
if( child_object != NULL ) {
childs.push_back(*child_object);
delete child_object;
}
}
else if( cname =="rule")
{
CXBindingsRule* rule = (CXBindingsRule*) CreateResFromNode(child,NULL);
if( rule != NULL ) {
rules.push_back(*rule);
delete rule;
}
}
else if( cname =="property")
{
CXBindingsProperty* property = (CXBindingsProperty*) CreateResFromNode(child,NULL);
if( property != NULL ) {
properties.push_back(*property);
delete property;
}
}
else if( cname =="foreach_child")
{
CXBindingsForEachChild* childrule = (CXBindingsForEachChild*) CreateResFromNode(child,NULL);
if( childrule != NULL ) {
childRules.push_back(*childrule);
delete childrule;
}
}
else if( cname =="category")
{
CXBindingsCategory* category = (CXBindingsCategory*) CreateResFromNode(child,NULL);
if( category != NULL ) {
categories.push_back(*category);
delete category;
}
}
else if( cname =="childcontainer")
{
CXBindingsChildContainer* container = (CXBindingsChildContainer*) CreateResFromNode(child,NULL);
if( container != NULL ) {
childcontainers.push_back(*container);
delete container;
}
}
else if( cname =="inherits")
{
CXBindingsInherits* inherit = (CXBindingsInherits*) CreateResFromNode(child,NULL);
if( inherit != NULL ) {
inherits.push_back(*inherit);
delete inherit;
}
}
child = child->next;
}
return object;
}
wxObject *wxToolBarAddOnXmlHandler::DoCreateResource()
{
wxToolBar* toolbar=NULL;
if (m_class == _T("tool"))
{
wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!"));
wxSize bitmapSize = m_toolbar->GetToolBitmapSize();
if (GetPosition() != wxDefaultPosition)
{
m_toolbar->AddTool(GetID(),
#if wxCHECK_VERSION(2, 9, 0)
wxEmptyString,
#endif
GetCenteredBitmap(_T("bitmap"), wxART_TOOLBAR, bitmapSize),
GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize),
#if !wxCHECK_VERSION(2, 9, 0)
GetBool(_T("toggle")),
GetPosition().x,
GetPosition().y,
NULL,
#else
wxITEM_NORMAL,
#endif
GetText(_T("tooltip")),
GetText(_T("longhelp")));
if (GetBool(_T("disabled")))
{
m_toolbar->Realize();
m_toolbar->EnableTool(GetID(),false);
}
}
else
{
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(_T("radio")))
kind = wxITEM_RADIO;
if (GetBool(_T("toggle")))
{
wxASSERT_MSG( kind == wxITEM_NORMAL,
_("can't have both toggleable and radion button at once") );
kind = wxITEM_CHECK;
}
m_toolbar->AddTool(GetID(),
GetText(_T("label")),
GetCenteredBitmap(_T("bitmap"), wxART_TOOLBAR, bitmapSize),
GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize),
kind,
GetText(_T("tooltip")),
GetText(_T("longhelp")));
if (GetBool(_T("disabled")))
{
m_toolbar->Realize();
m_toolbar->EnableTool(GetID(),false);
}
}
return m_toolbar; // must return non-NULL
}
else if (m_class == _T("separator"))
{
wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: separator not within a toolbar!"));
m_toolbar->AddSeparator();
return m_toolbar; // must return non-NULL
}
else /*<object class="wxToolBar">*/
{
m_isAddon=(m_class == _T("wxToolBarAddOn"));
if(m_isAddon)
{ // special case: Only add items to toolbar
toolbar=(wxToolBar*)m_instance;
// XRC_MAKE_INSTANCE(toolbar, wxToolBar);
}
else
{
int style = GetStyle(_T("style"), wxNO_BORDER | wxTB_HORIZONTAL);
#ifdef __WXMSW__
if (!(style & wxNO_BORDER)) style |= wxNO_BORDER;
#endif
XRC_MAKE_INSTANCE(toolbar, wxToolBar)
toolbar->Create(m_parentAsWindow,
GetID(),
GetPosition(),
GetSize(),
style,
GetName());
wxSize bmpsize = GetSize(_T("bitmapsize"));
if (!(bmpsize == wxDefaultSize))
toolbar->SetToolBitmapSize(bmpsize);
wxSize margins = GetSize(_T("margins"));
if (!(margins == wxDefaultSize))
toolbar->SetMargins(margins.x, margins.y);
long packing = GetLong(_T("packing"), -1);
if (packing != -1)
toolbar->SetToolPacking(packing);
long separation = GetLong(_T("separation"), -1);
if (separation != -1)
toolbar->SetToolSeparation(separation);
}
wxXmlNode *children_node = GetParamNode(_T("object"));
if (!children_node)
children_node = GetParamNode(_T("object_ref"));
if (children_node == NULL) return toolbar;
m_isInside = TRUE;
m_toolbar = toolbar;
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == _T("object") || n->GetName() == _T("object_ref")))
{
wxObject *created = CreateResFromNode(n, toolbar, NULL);
wxControl *control = wxDynamicCast(created, wxControl);
if (!IsOfClass(n, _T("tool")) &&
!IsOfClass(n, _T("separator")) &&
control != NULL &&
control != toolbar)
{
//Manager::Get()->GetLogManager()->DebugLog(F(_T("control=%p, parent=%p, toolbar=%p"), control, control->GetParent(), toolbar));
toolbar->AddControl(control);
}
}
n = n->GetNext();
}
toolbar->Realize();
m_isInside = FALSE;
m_toolbar = NULL;
if(!m_isAddon)
{
if (m_parentAsWindow && !GetBool(_T("dontattachtoframe")))
{
wxFrame *parentFrame = wxDynamicCast(m_parent, wxFrame);
if (parentFrame)
parentFrame->SetToolBar(toolbar);
}
}
m_isAddon=false;
return toolbar;
}
}
wxObject *wxToolBarXmlHandler::DoCreateResource()
{
if (m_class == wxT("tool"))
{
wxCHECK_MSG(m_toolbar, NULL, wxT("Incorrect syntax of XRC resource: tool not within a toolbar!"));
if (GetPosition() != wxDefaultPosition)
{
m_toolbar->AddTool(GetID(),
GetBitmap(wxT("bitmap"), wxART_TOOLBAR),
GetBitmap(wxT("bitmap2"), wxART_TOOLBAR),
GetBool(wxT("toggle")),
GetPosition().x,
GetPosition().y,
NULL,
GetText(wxT("tooltip")),
GetText(wxT("longhelp")));
}
else
{
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(wxT("radio")))
kind = wxITEM_RADIO;
if (GetBool(wxT("toggle")))
{
wxASSERT_MSG( kind == wxITEM_NORMAL,
_T("can't have both toggleable and radion button at once") );
kind = wxITEM_CHECK;
}
m_toolbar->AddTool(GetID(),
GetText(wxT("label")),
GetBitmap(wxT("bitmap"), wxART_TOOLBAR),
GetBitmap(wxT("bitmap2"), wxART_TOOLBAR),
kind,
GetText(wxT("tooltip")),
GetText(wxT("longhelp")));
if ( GetBool(wxT("disabled")) )
m_toolbar->EnableTool(GetID(), false);
}
return m_toolbar; // must return non-NULL
}
else if (m_class == wxT("separator"))
{
wxCHECK_MSG(m_toolbar, NULL, wxT("Incorrect syntax of XRC resource: separator not within a toolbar!"));
m_toolbar->AddSeparator();
return m_toolbar; // must return non-NULL
}
else /*<object class="wxToolBar">*/
{
int style = GetStyle(wxT("style"), wxNO_BORDER | wxTB_HORIZONTAL);
#ifdef __WXMSW__
if (!(style & wxNO_BORDER)) style |= wxNO_BORDER;
#endif
XRC_MAKE_INSTANCE(toolbar, wxToolBar)
toolbar->Create(m_parentAsWindow,
GetID(),
GetPosition(),
GetSize(),
style,
GetName());
wxSize bmpsize = GetSize(wxT("bitmapsize"));
if (!(bmpsize == wxDefaultSize))
toolbar->SetToolBitmapSize(bmpsize);
wxSize margins = GetSize(wxT("margins"));
if (!(margins == wxDefaultSize))
toolbar->SetMargins(margins.x, margins.y);
long packing = GetLong(wxT("packing"), -1);
if (packing != -1)
toolbar->SetToolPacking(packing);
long separation = GetLong(wxT("separation"), -1);
if (separation != -1)
toolbar->SetToolSeparation(separation);
if (HasParam(wxT("bg")))
toolbar->SetBackgroundColour(GetColour(wxT("bg")));
wxXmlNode *children_node = GetParamNode(wxT("object"));
if (!children_node)
children_node = GetParamNode(wxT("object_ref"));
if (children_node == NULL) return toolbar;
m_isInside = true;
m_toolbar = toolbar;
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object") || n->GetName() == wxT("object_ref")))
{
wxObject *created = CreateResFromNode(n, toolbar, NULL);
wxControl *control = wxDynamicCast(created, wxControl);
if (!IsOfClass(n, wxT("tool")) &&
!IsOfClass(n, wxT("separator")) &&
control != NULL)
toolbar->AddControl(control);
}
n = n->GetNext();
}
m_isInside = false;
m_toolbar = NULL;
toolbar->Realize();
if (m_parentAsWindow && !GetBool(wxT("dontattachtoframe")))
{
wxFrame *parentFrame = wxDynamicCast(m_parent, wxFrame);
if (parentFrame)
parentFrame->SetToolBar(toolbar);
}
return toolbar;
}
}
wxObject *wxAuiToolBarXmlHandler::DoCreateResource()
{
wxAuiToolBar* toolbar=NULL;
if (m_class == _T("tool"))
{
wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!"));
wxSize bitmapSize = m_toolbar->GetToolBitmapSize();
if (GetPosition() != wxDefaultPosition)
{
m_toolbar->AddTool(GetID(),
GetCenteredBitmap(_T("bitmap"), wxART_OTHER, wxSize(16,16)),
NULL, //GetCenteredBitmap(_T("bitmap2"), wxART_TOOLBAR, bitmapSize),
GetBool(_T("toggle")),
NULL,
GetText(_T("tooltip")),
GetText(_T("longhelp")));
if (GetBool(_T("disabled")))
{
m_toolbar->Realize();
m_toolbar->EnableTool(GetID(),false);
}
}
else
{
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(_T("radio")))
kind = wxITEM_RADIO;
if (GetBool(_T("toggle")))
{
wxASSERT_MSG( kind == wxITEM_NORMAL,
_("can't have both toggleable and radion button at once") );
kind = wxITEM_CHECK;
}
m_toolbar->AddTool(GetID(),
GetText(_T("label")),
GetCenteredBitmap(_T("bitmap"), wxART_OTHER, bitmapSize),
GetCenteredBitmap(_T("bitmap2"), wxART_OTHER, bitmapSize),
kind,
GetText(_T("tooltip")),
GetText(_T("longhelp")));
if (GetBool(_T("disabled")))
{
m_toolbar->Realize();
m_toolbar->EnableTool(GetID(),false);
}
}
return m_toolbar; // must return non-NULL
}
else if (m_class == _T("overflow_tool"))
{
wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: tool not within a toolbar!"));
wxSize bitmapSize = m_toolbar->GetToolBitmapSize();
wxItemKind kind = wxITEM_NORMAL;
if (GetBool(_T("radio")))
kind = wxITEM_RADIO;
if (GetBool(_T("toggle")))
{
wxASSERT_MSG( kind == wxITEM_NORMAL,
_("can't have both toggleable and radion button at once") );
kind = wxITEM_CHECK;
}
if (GetBool(_T("separator")))
kind = wxITEM_SEPARATOR;
m_toolbar->AddOverflowTool(GetID(),
GetText(_T("label")),
GetCenteredBitmap(_T("bitmap"), wxART_OTHER, bitmapSize),
GetText(_T("longhelp")),
kind,
GetBool(_T("prepend"),0) );
if (GetBool(_T("disabled")))
{
m_toolbar->Realize();
m_toolbar->EnableTool(GetID(),false);
}
return m_toolbar; // must return non-NULL
}
else if (m_class == _T("separator"))
{
wxCHECK_MSG(m_toolbar, NULL, _("Incorrect syntax of XRC resource: separator not within a toolbar!"));
m_toolbar->AddSeparator();
return m_toolbar; // must return non-NULL
}
else /*<object class="wxAuiToolBar">*/
{
toolbar=(wxAuiToolBar*)m_instance;
if(!toolbar && (m_class == _T("wxToolBarAddOn")))
{
toolbar = new wxAuiToolBar(m_parentAsWindow, -1, wxDefaultPosition, wxDefaultSize);
m_instance = (wxObject *)toolbar;
}
long style = GetStyle(_T("style"), -1);
if (style!=-1)
toolbar->SetWindowStyle(style);
style = GetStyle(_T("add_style"), -1);
if (style!=-1)
toolbar->SetWindowStyle(toolbar->GetWindowStyle() | style);
style = GetStyle(_T("remove_style"), -1);
if (style!=-1)
toolbar->SetWindowStyle(toolbar->GetWindowStyle() & ~style);
wxSize bmpsize = GetSize(_T("bitmapsize"));
// First find the generic bitmap size
if (!(bmpsize == wxDefaultSize))
toolbar->SetToolBitmapSize(bmpsize);
else
{
// if no generic size then find the platform dependent size
#ifdef __WXMSW__
bmpsize = GetSize(_T("bitmapsize_win"));
#endif
#ifdef __WXMAC__
bmpsize = GetSize(_T("bitmapsize_mac"));
#endif
#ifdef __WXGTK__
bmpsize = GetSize(_T("bitmapsize_unix"));
#endif
if (!(bmpsize == wxDefaultSize))
toolbar->SetToolBitmapSize(bmpsize);
}
wxSize margins = GetSize(_T("margins"));
if (!(margins == wxDefaultSize))
toolbar->SetMargins(margins.x, margins.y);
long packing = GetLong(_T("packing"), -1);
if (packing != -1)
toolbar->SetToolPacking(packing);
long separation = GetLong(_T("separation"), -1);
if (separation != -1)
toolbar->SetToolSeparation(separation);
wxXmlNode *children_node = GetParamNode(_T("object"));
if (!children_node)
children_node = GetParamNode(_T("object_ref"));
if (children_node == NULL) return toolbar;
m_isInside = TRUE;
m_toolbar = toolbar;
wxXmlNode *n = children_node;
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == _T("object") || n->GetName() == _T("object_ref")))
{
wxObject *created = CreateResFromNode(n, toolbar, NULL);
wxControl *control = wxDynamicCast(created, wxControl);
if (!IsOfClass(n, _T("tool")) &&
!IsOfClass(n, _T("separator")) &&
control != NULL &&
control != toolbar)
{
//Manager::Get()->GetLogManager()->DebugLog(F(_T("control=%p, parent=%p, toolbar=%p"), control, control->GetParent(), toolbar));
toolbar->AddControl(control);
}
}
n = n->GetNext();
}
toolbar->Realize();
m_isInside = FALSE;
m_toolbar = NULL;
m_isAddon=false;
return toolbar;
}
}
