{
}
-wxResourceManager theResourceManager;
+wxResourceManager *theResourceManager = NULL;
bool MyApp::OnInit(void)
{
- theResourceManager.Initialize();
- theResourceManager.ShowResourceEditor(TRUE);
+ theResourceManager = new wxResourceManager;
+ theResourceManager->Initialize();
+
+ theResourceManager->ShowResourceEditor(TRUE);
- if (argc > 1)
- theResourceManager.Load(argv[1]);
+ if (argc > 1)
+ theResourceManager->Load(argv[1]);
- SetTopWindow(theResourceManager.GetEditorFrame());
+ SetTopWindow(theResourceManager->GetEditorFrame());
- return TRUE;
+ return TRUE;
}
+int MyApp::OnExit(void)
+{
+ delete theResourceManager;
+ theResourceManager = NULL;
+ return 0;
+}
public:
MyApp(void);
bool OnInit(void);
+ int OnExit(void);
};
DECLARE_APP(MyApp)
-aaa ICON "dialoged.ico"
-DIALOGEDICON ICON "dialoged.ico"
+aaa ICON "bitmaps/dialoged.ico"
+DIALOGEDICON ICON "bitmaps/dialoged.ico"
-aiai_icn ICON "aiai.ico"
+DIALOG_ICON ICON "bitmaps/dialog.ico"
+FOLDER1_ICON ICON "bitmaps/folder1.ico"
+FOLDER2_ICON ICON "bitmaps/folder2.ico"
+BUTTONSM_ICON ICON "bitmaps/buttonsm.ico"
+
+/* For control list */
+ARROW_ICON ICON "bitmaps/arrow.ico"
+BUTTON_ICON ICON "bitmaps/button.ico"
+BMPBUTTON_ICON ICON "bitmaps/bmpbuttn.ico"
+STATICTEXT_ICON ICON "bitmaps/stattext.ico"
+STATICBMP_ICON ICON "bitmaps/statbmp.ico"
+STATICBOX_ICON ICON "bitmaps/statbox.ico"
+TEXTSING_ICON ICON "bitmaps/textsing.ico"
+TEXTMULT_ICON ICON "bitmaps/textmult.ico"
+LISTBOX_ICON ICON "bitmaps/listbox.ico"
+CHOICE_ICON ICON "bitmaps/choice.ico"
+COMBOBOX_ICON ICON "bitmaps/combobox.ico"
+CHECKBOX_ICON ICON "bitmaps/checkbox.ico"
+SLIDER_ICON ICON "bitmaps/slider.ico"
+GAUGE_ICON ICON "bitmaps/gauge.ico"
+RADIOBOX_ICON ICON "bitmaps/radiobox.ico"
+RADIOBTN_ICON ICON "bitmaps/radiobtn.ico"
+SCROLBAR_ICON ICON "bitmaps/scrolbar.ico"
+
+aiai_icn ICON "bitmaps/aiai.ico"
#include "wx/msw/wx.rc"
DIALOGBOXTOOL BITMAP "bitmaps/dialog.bmp"
#include "winprop.h"
#include "editrpal.h"
#include "dlghndlr.h"
-
-extern void wxResourceEditWindow(wxWindow *win);
+#include "edlist.h"
IMPLEMENT_CLASS(wxResourceEditorDialogHandler, wxEvtHandler)
IMPLEMENT_CLASS(wxResourceEditorControlHandler, wxEvtHandler)
oldDragY = 0;
dragTolerance = 3;
checkTolerance = TRUE;
+ m_mouseCaptured = FALSE;
+// m_treeItem = 0;
+}
+
+wxResourceEditorDialogHandler::~wxResourceEditorDialogHandler(void)
+{
}
void wxResourceEditorDialogHandler::OnItemSelect(wxControl *item, bool select)
resourceManager->RemoveSelection(item);
}
-bool wxResourceEditorDialogHandler::OnClose(void)
-{
- handlerDialog->PopEventHandler();
-
- // Now reset all child event handlers
- wxNode *node = handlerDialog->GetChildren()->First();
- while ( node )
- {
- wxWindow *child = (wxWindow *)node->Data();
- wxEvtHandler *childHandler = child->GetEventHandler();
- if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler != child )
- {
- child->PopEventHandler();
- delete childHandler;
- }
- node = node->Next();
- }
-
- // Save the information before deleting the dialog.
- resourceManager->InstantiateResourceFromWindow(handlerResource, handlerDialog, TRUE);
-
- resourceManager->DisassociateResource(handlerDialog, FALSE);
-
- handlerDialog->Show(FALSE);
- delete this;
- return TRUE;
-}
-
void wxResourceEditorDialogHandler::OnPaint(wxPaintEvent& event)
{
wxPaintDC dc(handlerDialog);
{
if (keys & wxKEY_CTRL)
{
- wxResourceEditWindow(handlerDialog);
+ wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
+ return;
+ }
+
+ // Deselect all items if click on panel
+ if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
+ {
+ int needsRefresh = 0;
+ wxNode *node = handlerDialog->GetChildren()->First();
+ while (node)
+ {
+ wxControl *item = (wxControl *)node->Data();
+ wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
+ if (item->IsKindOf(CLASSINFO(wxControl)) && childHandler->IsSelected())
+ {
+ needsRefresh ++;
+ OnItemSelect(item, FALSE);
+ childHandler->SelectItem(FALSE);
+ }
+ node = node->Next();
+ }
+ if (needsRefresh > 0)
+ {
+ wxClientDC dc(handlerDialog);
+ dc.Clear();
+ handlerDialog->Refresh();
+ }
+ return;
+ }
+
+ wxResourceManager* manager = resourceManager;
+
+ switch (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection())
+ {
+ case RESED_BUTTON:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxButton", x, y);
+ break;
+ case RESED_BMPBUTTON:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxBitmapButton", x, y, TRUE);
+ break;
+ case RESED_STATICTEXT:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticText", x, y);
+ break;
+ case RESED_STATICBMP:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBitmap", x, y, TRUE);
+ break;
+ case RESED_TEXTCTRL_SINGLE:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (single-line)", x, y);
+ break;
+ case RESED_TEXTCTRL_MULTIPLE:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (multi-line)", x, y);
+ break;
+ case RESED_CHOICE:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxChoice", x, y);
+ break;
+ case RESED_CHECKBOX:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxCheckBox", x, y);
+ break;
+ case RESED_RADIOBOX:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxRadioBox", x, y);
+ break;
+ case RESED_LISTBOX:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxListBox", x, y);
+ break;
+ case RESED_SLIDER:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxSlider", x, y);
+ break;
+ case RESED_GAUGE:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxGauge", x, y);
+ break;
+ case RESED_STATICBOX:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBox", x, y);
+ break;
+ case RESED_SCROLLBAR:
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxScrollBar", x, y);
+ break;
+ default:
+ break;
+ }
+
+ // Now switch pointer on.
+ if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() != RESED_POINTER)
+ {
+ wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->SetItemState(RESED_POINTER, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+ }
+}
+
+#if 0
+void wxResourceEditorDialogHandler::OnLeftClick(int x, int y, int keys)
+{
+ if (keys & wxKEY_CTRL)
+ {
+ wxResourceManager::GetCurrentResourceManager()->EditWindow(handlerDialog);
return;
}
return;
}
+ wxResourceManager* manager = resourceManager;
+
switch (resourceManager->GetEditorPalette()->currentlySelected)
{
case PALETTE_FRAME:
resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxButton", x, y, TRUE);
break;
case PALETTE_MESSAGE:
- resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxMessage", x, y);
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticText", x, y);
break;
case PALETTE_BITMAP_MESSAGE:
- resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxMessage", x, y, TRUE);
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxStaticBitmap", x, y, TRUE);
break;
case PALETTE_TEXT:
- resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxText", x, y);
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (single-line)", x, y);
break;
case PALETTE_MULTITEXT:
- resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxMultiText", x, y);
+ resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxTextCtrl (multi-line)", x, y);
break;
case PALETTE_CHOICE:
resourceManager->CreatePanelItem(handlerResource, handlerDialog, "wxChoice", x, y);
}
// Now switch pointer on.
- if (resourceManager->GetEditorPalette()->currentlySelected != PALETTE_ARROW)
+ if (manager->GetEditorPalette()->currentlySelected != PALETTE_ARROW)
{
- resourceManager->GetEditorPalette()->ToggleTool(resourceManager->GetEditorPalette()->currentlySelected, FALSE);
- resourceManager->GetEditorPalette()->ToggleTool(PALETTE_ARROW, TRUE);
- resourceManager->GetEditorPalette()->currentlySelected = PALETTE_ARROW;
+ manager->GetEditorPalette()->ToggleTool(manager->GetEditorPalette()->currentlySelected, FALSE);
+ manager->GetEditorPalette()->ToggleTool(PALETTE_ARROW, TRUE);
+ manager->GetEditorPalette()->currentlySelected = PALETTE_ARROW;
}
}
+#endif
void wxResourceEditorDialogHandler::OnRightClick(int x, int y, int keys)
{
wxMenu *menu = resourceManager->GetPopupMenu();
menu->SetClientData((char *)handlerDialog);
-#ifdef __MOTIF__
- handlerDialog->FakePopupMenu(menu, x, y);
-#else
handlerDialog->PopupMenu(menu, x, y);
-#endif
}
void wxResourceEditorDialogHandler::OnItemLeftClick(wxControl *item, int x, int y, int keys)
{
if (keys & wxKEY_CTRL)
{
- wxResourceEditWindow(item);
+ wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
return;
}
wxMenu *menu = resourceManager->GetPopupMenu();
menu->SetClientData((char *)item);
-#ifdef __MOTIF__
- handlerDialog->FakePopupMenu(menu, x, y);
-#else
handlerDialog->PopupMenu(menu, x, y);
-#endif
}
// An event outside any items: may be a drag event.
if (event.ControlDown()) keys = keys | wxKEY_CTRL;
if (event.LeftUp())
- OnLeftClick(x, y, keys);
+ {
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
+
+ OnLeftClick(x, y, keys);
+ }
else if (event.RightUp())
- OnRightClick(x, y, keys);
+ {
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
+
+ OnRightClick(x, y, keys);
+ }
}
else
event.Skip();
checkTolerance = FALSE;
}
}
- if (dragging && dragItem && dragMode == wxDRAG_MODE_START_LEFT)
+ if (event.LeftDClick())
+ {
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
+
+ wxResourceManager::GetCurrentResourceManager()->EditWindow(item);
+ }
+ else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_LEFT)
{
dragMode = wxDRAG_MODE_CONTINUE_LEFT;
wxClientDC dc(handlerDialog);
childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
oldDragX = x; oldDragY = y;
+ if (!m_mouseCaptured)
+ {
+ handlerDialog->CaptureMouse();
+ m_mouseCaptured = TRUE;
+ }
}
else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_LEFT)
{
wxClientDC dc(handlerDialog);
dragMode = wxDRAG_MODE_NONE;
checkTolerance = TRUE;
+
childHandler->OnDragContinue(FALSE, oldDragX, oldDragY, keys, dc, selectionHandle);
childHandler->OnDragEnd(x, y, keys, dc, selectionHandle);
+
dragItem = NULL;
dragType = wxDRAG_TYPE_NONE;
+
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
}
else if (dragging && dragItem && dragMode == wxDRAG_MODE_START_RIGHT)
{
dragMode = wxDRAG_MODE_CONTINUE_RIGHT;
childHandler->OnDragBegin(x, y, keys, dc, selectionHandle);
oldDragX = x; oldDragY = y;
+
+ if (!m_mouseCaptured)
+ {
+ handlerDialog->CaptureMouse();
+ m_mouseCaptured = TRUE;
+ }
}
else if (dragging && dragItem && dragMode == wxDRAG_MODE_CONTINUE_RIGHT)
{
checkTolerance = TRUE;
dragItem = NULL;
dragType = wxDRAG_TYPE_NONE;
+
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
}
else if (event.IsButton())
{
firstDragX = x;
firstDragY = y;
dragType = selectionHandle;
+
+ if (!m_mouseCaptured)
+ {
+ handlerDialog->CaptureMouse();
+ m_mouseCaptured = TRUE;
+ }
}
else if (event.RightDown())
{
firstDragX = x;
firstDragY = y;
dragType = selectionHandle;
+
+ if (!m_mouseCaptured)
+ {
+ handlerDialog->CaptureMouse();
+ m_mouseCaptured = TRUE;
+ }
}
else if (event.LeftUp())
{
OnLeftClick(x, y, keys);
dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
+
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
}
else if (event.RightUp())
{
OnRightClick(x, y, keys);
dragItem = NULL; dragMode = wxDRAG_MODE_NONE; dragType = wxDRAG_TYPE_NONE;
+
+ if (m_mouseCaptured)
+ {
+ handlerDialog->ReleaseMouse();
+ m_mouseCaptured = FALSE;
+ }
}
}
}
isSelected = FALSE;
dragOffsetX = 0;
dragOffsetY = 0;
+// m_treeItem = 0;
+}
+
+wxResourceEditorControlHandler::~wxResourceEditorControlHandler(void)
+{
}
/*
dc.SetLogicalFunction(wxXOR);
- dc.SetPen(wxBLACK_DASHED_PEN);
+ wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
+ dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
dc.SetOptimization(TRUE);
dc.BeginDrawing();
dc.SetLogicalFunction(wxXOR);
- dc.SetPen(wxBLACK_DASHED_PEN);
+ wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
+ dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
DrawBoundingBox(dc, x1, y1, width1, height1);
else
{
dc.BeginDrawing();
-
dc.SetLogicalFunction(wxXOR);
- dc.SetPen(wxBLACK_DASHED_PEN);
+ wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
+ dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
DrawBoundingBox(dc, (int)(x - dragOffsetX), (int)(y - dragOffsetY), width, height);
}
node = node->Next();
}
-
dc.EndDrawing();
}
}
node = node->Next();
}
}
-
dc.SetOptimization(FALSE);
dc.SetLogicalFunction(wxCOPY);
// by default.
void wxResourceEditorControlHandler::OnMouseEvent(wxMouseEvent& event)
{
+/*
if ((event.m_eventType == wxEVENT_TYPE_LEFT_DCLICK) ||
(event.m_eventType == wxEVENT_TYPE_RIGHT_DCLICK))
return;
+*/
wxWindow *panel = handlerControl->GetParent();
if ( !panel->GetEventHandler()->IsKindOf(CLASSINFO(wxResourceEditorDialogHandler)) )
return;
int firstDragY;
int oldDragX;
int oldDragY;
+ bool m_mouseCaptured;
+// long m_treeItem;
wxResourceEditorDialogHandler(wxPanel *dialog, wxItemResource *resource, wxEvtHandler *oldHandler,
wxResourceManager *manager);
- ~wxResourceEditorDialogHandler(void) {}
-
- bool OnClose(void);
+ ~wxResourceEditorDialogHandler(void);
void OnPaint(wxPaintEvent& event);
void OnMouseEvent(wxMouseEvent& event);
void PaintSelectionHandles(wxDC& dc);
void ProcessItemEvent(wxControl *item, wxMouseEvent& event, int selectionHandle);
+// Accessors
+/*
+ inline long GetTreeItem() const { return m_treeItem; }
+ inline void SetTreeItem(long item) { m_treeItem = item; }
+*/
+
DECLARE_EVENT_TABLE()
};
bool isSelected;
int handleSize; // selection handle size
int handleMargin; // Distance between item edge and handle edge
+ long m_treeItem;
static int dragOffsetX; // Distance between pointer at start of drag and
static int dragOffsetY; // top-left of item
wxResourceEditorControlHandler(wxControl *control, wxEvtHandler *oldHandler);
- ~wxResourceEditorControlHandler(void) {}
+ ~wxResourceEditorControlHandler(void);
void OnMouseEvent(wxMouseEvent& event);
virtual void OnRightClick(int x, int y, int keys);
virtual void OnSelect(bool select);
+// Accessors
+/*
+ inline long GetTreeItem() const { return m_treeItem; }
+ inline void SetTreeItem(long item) { m_treeItem = item; }
+*/
+
DECLARE_EVENT_TABLE()
};
#include "reseditr.h"
#include "editrpal.h"
-// Bitmaps for palette
-wxBitmap *PaletteFrameBitmap = NULL;
-wxBitmap *PaletteDialogBoxBitmap = NULL;
-wxBitmap *PalettePanelBitmap = NULL;
-wxBitmap *PaletteCanvasBitmap = NULL;
-wxBitmap *PaletteTextWindowBitmap = NULL;
-wxBitmap *PaletteMessageBitmap = NULL;
-wxBitmap *PaletteButtonBitmap = NULL;
-wxBitmap *PaletteCheckBoxBitmap = NULL;
-wxBitmap *PaletteListBoxBitmap = NULL;
-wxBitmap *PaletteRadioBoxBitmap = NULL;
-wxBitmap *PaletteChoiceBitmap = NULL;
-wxBitmap *PaletteTextBitmap = NULL;
-wxBitmap *PaletteMultiTextBitmap = NULL;
-wxBitmap *PaletteSliderBitmap = NULL;
-wxBitmap *PaletteArrowBitmap = NULL;
-wxBitmap *PaletteGroupBitmap = NULL;
-wxBitmap *PaletteGaugeBitmap = NULL;
-wxBitmap *PalettePictureBitmap = NULL;
-wxBitmap *PaletteBitmapButtonBitmap = NULL;
-wxBitmap *PaletteScrollbarBitmap = NULL;
-
#ifdef __X__
#include "bitmaps/frame.xbm"
#include "bitmaps/dialog.xbm"
case PALETTE_PANEL:
managerFrame->SetStatusText("wxPanel");
break;
+#if 0
case PALETTE_CANVAS:
managerFrame->SetStatusText("wxCanvas");
break;
case PALETTE_TEXT_WINDOW:
managerFrame->SetStatusText("wxTextWindow");
break;
+#endif
case PALETTE_BUTTON:
managerFrame->SetStatusText("wxButton");
break;
case PALETTE_MESSAGE:
- managerFrame->SetStatusText("wxMessage");
+ managerFrame->SetStatusText("wxStaticText");
break;
case PALETTE_TEXT:
- managerFrame->SetStatusText("wxText");
+ managerFrame->SetStatusText("wxTextCtrl (single-line)");
break;
case PALETTE_MULTITEXT:
- managerFrame->SetStatusText("wxMultiText");
+ managerFrame->SetStatusText("wxTextCtrl (multi-line)");
break;
case PALETTE_CHOICE:
managerFrame->SetStatusText("wxChoice");
managerFrame->SetStatusText("wxSlider");
break;
case PALETTE_GROUPBOX:
- managerFrame->SetStatusText("wxGroupBox");
+ managerFrame->SetStatusText("wxStaticBox");
break;
case PALETTE_GAUGE:
managerFrame->SetStatusText("wxGauge");
break;
case PALETTE_BITMAP_MESSAGE:
- managerFrame->SetStatusText("Bitmap wxMessage");
+ managerFrame->SetStatusText("wxStaticBitmap");
break;
case PALETTE_BITMAP_BUTTON:
- managerFrame->SetStatusText("Bitmap wxButton");
+ managerFrame->SetStatusText("wxBitmapButton");
break;
case PALETTE_SCROLLBAR:
managerFrame->SetStatusText("wxScrollBar");
dc.DrawLine(0, h-1, w, h-1);
}
-bool wxResourceManager::InitializeTools(void)
+EditorToolPalette *wxResourceManager::OnCreatePalette(wxFrame *parent)
{
// Load palette bitmaps
#ifdef __WINDOWS__
- PaletteFrameBitmap = new wxBitmap("FRAMETOOL");
- PaletteDialogBoxBitmap = new wxBitmap("DIALOGBOXTOOL");
- PalettePanelBitmap = new wxBitmap("PANELTOOL");
- PaletteCanvasBitmap = new wxBitmap("CANVASTOOL");
- PaletteTextWindowBitmap = new wxBitmap("TEXTWINDOWTOOL");
- PaletteMessageBitmap = new wxBitmap("MESSAGETOOL");
- PaletteButtonBitmap = new wxBitmap("BUTTONTOOL");
- PaletteCheckBoxBitmap = new wxBitmap("CHECKBOXTOOL");
- PaletteListBoxBitmap = new wxBitmap("LISTBOXTOOL");
- PaletteRadioBoxBitmap = new wxBitmap("RADIOBOXTOOL");
- PaletteChoiceBitmap = new wxBitmap("CHOICETOOL");
- PaletteTextBitmap = new wxBitmap("TEXTTOOL");
- PaletteMultiTextBitmap = new wxBitmap("MULTITEXTTOOL");
- PaletteSliderBitmap = new wxBitmap("SLIDERTOOL");
- PaletteArrowBitmap = new wxBitmap("ARROWTOOL");
- PaletteGroupBitmap = new wxBitmap("GROUPTOOL");
- PaletteGaugeBitmap = new wxBitmap("GAUGETOOL");
- PalettePictureBitmap = new wxBitmap("PICTURETOOL");
- PaletteBitmapButtonBitmap = new wxBitmap("BMPBUTTONTOOL");
- PaletteScrollbarBitmap = new wxBitmap("SCROLLBARTOOL");
+ wxBitmap PaletteMessageBitmap("MESSAGETOOL");
+ wxBitmap PaletteButtonBitmap("BUTTONTOOL");
+ wxBitmap PaletteCheckBoxBitmap("CHECKBOXTOOL");
+ wxBitmap PaletteListBoxBitmap("LISTBOXTOOL");
+ wxBitmap PaletteRadioBoxBitmap("RADIOBOXTOOL");
+ wxBitmap PaletteChoiceBitmap("CHOICETOOL");
+ wxBitmap PaletteTextBitmap("TEXTTOOL");
+ wxBitmap PaletteMultiTextBitmap("MULTITEXTTOOL");
+ wxBitmap PaletteSliderBitmap("SLIDERTOOL");
+ wxBitmap PaletteArrowBitmap("ARROWTOOL");
+ wxBitmap PaletteGroupBitmap("GROUPTOOL");
+ wxBitmap PaletteGaugeBitmap("GAUGETOOL");
+ wxBitmap PalettePictureBitmap("PICTURETOOL");
+ wxBitmap PaletteBitmapButtonBitmap("BMPBUTTONTOOL");
+ wxBitmap PaletteScrollbarBitmap("SCROLLBARTOOL");
#endif
#ifdef __X__
- PaletteFrameBitmap = new wxBitmap(frame_bits, frame_width, frame_height);
- PaletteDialogBoxBitmap = new wxBitmap(dialog_bits, dialog_width, dialog_height);
- PalettePanelBitmap = new wxBitmap(panel_bits, panel_width, panel_height);
- PaletteCanvasBitmap = new wxBitmap(canvas_bits, canvas_width, canvas_height);
- PaletteTextWindowBitmap = new wxBitmap(textsw_bits, textsw_width, textsw_height);
- PaletteMessageBitmap = new wxBitmap(message_bits, message_width, message_height);
- PaletteButtonBitmap = new wxBitmap(button_bits, button_width, button_height);
- PaletteCheckBoxBitmap = new wxBitmap(check_bits, check_width, check_height);
- PaletteListBoxBitmap = new wxBitmap(listbox_bits, listbox_width, listbox_height);
- PaletteRadioBoxBitmap = new wxBitmap(radio_bits, radio_width, radio_height);
- PaletteChoiceBitmap = new wxBitmap(choice_bits, choice_width, choice_height);
- PaletteTextBitmap = new wxBitmap(text_bits, text_width, text_height);
- PaletteMultiTextBitmap = new wxBitmap(mtext_bits, mtext_width, mtext_height);
- PaletteSliderBitmap = new wxBitmap(slider_bits, slider_width, slider_height);
- PaletteArrowBitmap = new wxBitmap(arrow_bits, arrow_width, arrow_height);
- PaletteGroupBitmap = new wxBitmap(group_bits, group_width, group_height);
- PaletteGaugeBitmap = new wxBitmap(gauge_bits, gauge_width, gauge_height);
- PalettePictureBitmap = new wxBitmap(picture_bits, picture_width, picture_height);
- PaletteBitmapButtonBitmap = new wxBitmap(bmpbuttn_bits, bmpbuttn_width, bmpbuttn_height);
- PaletteScrollbarBitmap = new wxBitmap(scroll_bits, scroll_width, scroll_height);
+ wxBitmap PaletteMessageBitmap(message_bits, message_width, message_height);
+ wxBitmap PaletteButtonBitmap(button_bits, button_width, button_height);
+ wxBitmap PaletteCheckBoxBitmap(check_bits, check_width, check_height);
+ wxBitmap PaletteListBoxBitmap(listbox_bits, listbox_width, listbox_height);
+ wxBitmap PaletteRadioBoxBitmap(radio_bits, radio_width, radio_height);
+ wxBitmap PaletteChoiceBitmap(choice_bits, choice_width, choice_height);
+ wxBitmap PaletteTextBitmap(text_bits, text_width, text_height);
+ wxBitmap PaletteMultiTextBitmap(mtext_bits, mtext_width, mtext_height);
+ wxBitmap PaletteSliderBitmap(slider_bits, slider_width, slider_height);
+ wxBitmap PaletteArrowBitmap(arrow_bits, arrow_width, arrow_height);
+ wxBitmap PaletteGroupBitmap(group_bits, group_width, group_height);
+ wxBitmap PaletteGaugeBitmap(gauge_bits, gauge_width, gauge_height);
+ wxBitmap PalettePictureBitmap(picture_bits, picture_width, picture_height);
+ wxBitmap PaletteBitmapButtonBitmap(bmpbuttn_bits, bmpbuttn_width, bmpbuttn_height);
+ wxBitmap PaletteScrollbarBitmap(scroll_bits, scroll_width, scroll_height);
#endif
- return TRUE;
-}
-EditorToolPalette *wxResourceManager::OnCreatePalette(wxFrame *parent)
-{
EditorToolPalette *palette = new EditorToolPalette(this, parent, 0, 0, -1, -1, wxNO_BORDER, // wxTB_3DBUTTONS,
wxVERTICAL, 1);
#endif
*/
-// palette->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
palette->AddTool(PALETTE_ARROW, PaletteArrowBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "Pointer");
-/*
- palette->AddTool(PALETTE_FRAME, PaletteFrameBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxFrame");
- palette->AddTool(PALETTE_DIALOG_BOX, PaletteDialogBoxBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxDialog");
- palette->AddTool(PALETTE_PANEL, PalettePanelBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxPanel");
- palette->AddTool(PALETTE_CANVAS, PaletteCanvasBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxCanvas");
- palette->AddTool(PALETTE_TEXT_WINDOW, PaletteTextWindowBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxTextWindow");
-
-*/
- palette->AddTool(PALETTE_MESSAGE, PaletteMessageBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxMessage");
- palette->AddTool(PALETTE_BITMAP_MESSAGE, PalettePictureBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "Picture wxMessage");
+ palette->AddTool(PALETTE_MESSAGE, PaletteMessageBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxStaticText");
+ palette->AddTool(PALETTE_BITMAP_MESSAGE, PalettePictureBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxStaticBitmap");
palette->AddTool(PALETTE_BUTTON, PaletteButtonBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "Button");
- palette->AddTool(PALETTE_BITMAP_BUTTON, PaletteBitmapButtonBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "Picture wxButton");
+ palette->AddTool(PALETTE_BITMAP_BUTTON, PaletteBitmapButtonBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxBitmapButton");
palette->AddTool(PALETTE_CHECKBOX, PaletteCheckBoxBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxCheckBox");
palette->AddTool(PALETTE_RADIOBOX, PaletteRadioBoxBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxRadioBox");
palette->AddTool(PALETTE_LISTBOX, PaletteListBoxBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxListBox");
palette->AddTool(PALETTE_CHOICE, PaletteChoiceBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxChoice");
- palette->AddTool(PALETTE_TEXT, PaletteTextBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxText");
- palette->AddTool(PALETTE_MULTITEXT, PaletteMultiTextBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxMultiText");
+ palette->AddTool(PALETTE_TEXT, PaletteTextBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxTextCtrl (single-line)");
+ palette->AddTool(PALETTE_MULTITEXT, PaletteMultiTextBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxTextCtrl (multi-line)");
palette->AddTool(PALETTE_SLIDER, PaletteSliderBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxSlider");
- palette->AddTool(PALETTE_GROUPBOX, PaletteGroupBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxGroupBox");
+ palette->AddTool(PALETTE_GROUPBOX, PaletteGroupBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxStaticBox");
palette->AddTool(PALETTE_GAUGE, PaletteGaugeBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxGauge");
palette->AddTool(PALETTE_SCROLLBAR, PaletteScrollbarBitmap, (wxBitmap *)NULL, TRUE, 0, -1, NULL, "wxScrollBar");
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: edlist.cpp
+// Purpose: Resource editor project management tree
+// Author: Julian Smart
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) Julian Smart
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "edlist.h"
+#endif
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+
+#include "wx/checkbox.h"
+#include "wx/button.h"
+#include "wx/choice.h"
+#include "wx/listbox.h"
+#include "wx/radiobox.h"
+#include "wx/statbox.h"
+#include "wx/gauge.h"
+#include "wx/slider.h"
+#include "wx/textctrl.h"
+#endif
+
+#include "edlist.h"
+#include "reseditr.h"
+
+BEGIN_EVENT_TABLE(wxResourceEditorControlList, wxListCtrl)
+END_EVENT_TABLE()
+
+wxResourceEditorControlList::wxResourceEditorControlList(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+ long style):
+ wxListCtrl(parent, id, pos, size, style), m_imageList(16, 16, TRUE)
+{
+ Initialize();
+}
+
+wxResourceEditorControlList::~wxResourceEditorControlList()
+{
+ SetImageList(NULL, wxIMAGE_LIST_SMALL);
+}
+
+// Load icons and add to the list
+void wxResourceEditorControlList::Initialize()
+{
+ wxIcon icon1("ARROW_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon1);
+
+ wxIcon icon2("BUTTON_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon2);
+
+ wxIcon icon3("BMPBUTTON_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon3);
+
+ wxIcon icon4("STATICTEXT_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon4);
+
+ wxIcon icon5("STATICBMP_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon5);
+
+ wxIcon icon6("STATICBOX_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon6);
+
+ wxIcon icon7("TEXTSING_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon7);
+
+ wxIcon icon8("TEXTMULT_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon8);
+
+ wxIcon icon9("LISTBOX_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon9);
+
+ wxIcon icon10("CHOICE_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon10);
+
+ wxIcon icon11("COMBOBOX_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon11);
+
+ wxIcon icon12("CHECKBOX_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon12);
+
+ wxIcon icon13("SLIDER_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon13);
+
+ wxIcon icon14("GAUGE_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon14);
+
+ wxIcon icon15("RADIOBOX_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon15);
+
+ wxIcon icon16("RADIOBTN_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon16);
+
+ wxIcon icon17("SCROLBAR_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon17);
+
+ SetImageList(& m_imageList, wxIMAGE_LIST_SMALL);
+
+ long id = InsertItem(0, "Pointer", 0);
+ id = InsertItem(1, "wxButton", 1);
+ id = InsertItem(2, "wxBitmapButton", 2);
+ id = InsertItem(3, "wxStaticText", 3);
+ id = InsertItem(4, "wxStaticBitmap", 4);
+ id = InsertItem(5, "wxStaticBox", 5);
+ id = InsertItem(6, "wxTextCtrl", 6);
+ id = InsertItem(7, "wxTextCtrl", 7);
+ id = InsertItem(8, "wxListBox", 8);
+ id = InsertItem(9, "wxChoice", 9);
+ id = InsertItem(10, "wxComboBox", 10);
+ id = InsertItem(11, "wxCheckBox", 11);
+ id = InsertItem(12, "wxSlider", 12);
+ id = InsertItem(13, "wxGauge", 13);
+ id = InsertItem(14, "wxRadioBox", 14);
+ id = InsertItem(15, "wxRadioButton", 15);
+ id = InsertItem(16, "wxScrollBar", 16);
+
+/*
+ InsertItem(RESED_TREECTRL, "wxTreeCtrl", 16);
+ InsertItem(RESED_LISTCTRL, "wxListCtrl", 17);
+ InsertItem(RESED_SPINBUTTON, "wxSpinButton", 18);
+*/
+
+// SetColumnWidth(-1, 80);
+}
+
+// Get selection, or -1
+long wxResourceEditorControlList::GetSelection() const
+{
+ return GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+}
+
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: edlist.h
+// Purpose: Resource editor list of controls
+// Author: Julian Smart
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) Julian Smart
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _EDLIST_H_
+#define _EDLIST_H_
+
+#include <wx/listctrl.h>
+#include <wx/imaglist.h>
+
+class wxResourceEditorControlList: public wxListCtrl
+{
+public:
+ wxResourceEditorControlList(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+ long style = wxLC_SMALL_ICON|wxLC_AUTOARRANGE|wxLC_SINGLE_SEL);
+ ~wxResourceEditorControlList();
+
+ // Load icons and add to the list
+ void Initialize();
+
+ // Get selection, or -1
+ long GetSelection() const;
+
+DECLARE_EVENT_TABLE()
+
+protected:
+ wxImageList m_imageList;
+};
+
+#endif
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: edtree.cpp
+// Purpose: Resource editor project management tree
+// Author: Julian Smart
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) Julian Smart
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "edtree.h"
+#endif
+
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+
+#include "wx/checkbox.h"
+#include "wx/button.h"
+#include "wx/choice.h"
+#include "wx/listbox.h"
+#include "wx/radiobox.h"
+#include "wx/statbox.h"
+#include "wx/gauge.h"
+#include "wx/slider.h"
+#include "wx/textctrl.h"
+#endif
+
+#include "edtree.h"
+#include "reseditr.h"
+
+BEGIN_EVENT_TABLE(wxResourceEditorProjectTree, wxTreeCtrl)
+ EVT_LEFT_DCLICK(wxResourceEditorProjectTree::LeftDClick)
+ EVT_TREE_SEL_CHANGED(IDC_TREECTRL, wxResourceEditorProjectTree::OnSelChanged)
+END_EVENT_TABLE()
+
+wxResourceEditorProjectTree::wxResourceEditorProjectTree(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+ long style):
+ wxTreeCtrl(parent, id, pos, size, style)
+{
+}
+
+void wxResourceEditorProjectTree::LeftDClick(wxMouseEvent& event)
+{
+#if 0
+ long sel = GetSelection();
+ if (sel == -1)
+ return;
+
+ if (GetItemData(sel) == 0)
+ return;
+
+ wxItemResource* res = (wxItemResource*) GetItemData(sel);
+ wxString resType(res->GetType());
+ if (resType != "wxDialog" && resType != "wxDialogBox" && resType != "wxPanel")
+ return;
+
+ wxResourceEditorFrame *frame = (wxResourceEditorFrame *)wxWindow::GetParent();
+ wxResourceManager *manager = frame->manager;
+
+ manager->EditSelectedResource();
+#endif
+}
+
+void wxResourceEditorProjectTree::OnSelChanged(wxTreeEvent& event)
+{
+ long sel = GetSelection();
+ if (sel == -1)
+ return;
+
+ if (GetItemData(sel) == 0)
+ return;
+
+ if (m_invalid)
+ return;
+
+ wxItemResource* res = (wxItemResource*) GetItemData(sel);
+ wxString resType(res->GetType());
+ if (resType != "wxDialog" && resType != "wxDialogBox" && resType != "wxPanel")
+ return;
+
+ wxResourceManager::GetCurrentResourceManager()->Edit(res);
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: edtree.h
+// Purpose: Resource editor project management tree control
+// Author: Julian Smart
+// Modified by:
+// Created: 04/01/98
+// RCS-ID: $Id$
+// Copyright: (c) Julian Smart
+// Licence: wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _EDTREE_H_
+#define _EDTREE_H_
+
+#include <wx/treectrl.h>
+
+class wxResourceEditorProjectTree: public wxTreeCtrl
+{
+public:
+ wxResourceEditorProjectTree(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+ long style = wxTR_HAS_BUTTONS);
+
+ void LeftDClick(wxMouseEvent& event);
+ void OnSelChanged(wxTreeEvent& event);
+
+ inline void SetInvalid(bool invalid) { m_invalid = invalid; }
+
+protected:
+ bool m_invalid; // While TRUE, don't respond to selections etc.
+
+DECLARE_EVENT_TABLE()
+
+};
+
+#endif
+
PROGRAM=dialoged
-OBJECTS = dialoged.obj editrpal.obj reseditr.obj dlghndlr.obj reswrite.obj winprop.obj
+OBJECTS = dialoged.obj editrpal.obj reseditr.obj dlghndlr.obj reswrite.obj winprop.obj edtree.obj edlist.obj
all: wxprop dialoged.exe
$(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
<<
+edtree.obj: winprop.h reseditr.h editrpal.h edtree.h edtree.$(SRCSUFF) $(DUMMYOBJ)
+ $(cc) @<<
+$(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
+<<
+
+edlist.obj: winprop.h reseditr.h edlist.h edlist.$(SRCSUFF) $(DUMMYOBJ)
+ $(cc) @<<
+$(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
+<<
+
dlghndlr.obj: winprop.h reseditr.h editrpal.h dlghndlr.$(SRCSUFF) $(DUMMYOBJ)
$(cc) @<<
$(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
#include "winprop.h"
#include "editrpal.h"
#include "dlghndlr.h"
+#include "edtree.h"
+#include "edlist.h"
static void ObjectMenuProc(wxMenu& menu, wxCommandEvent& event);
-void wxResourceEditWindow(wxWindow *win);
-wxWindowPropertyInfo *wxCreatePropertyInfoForWindow(wxWindow *win);
-wxResourceManager *wxResourceManager::currentResourceManager = NULL;
-
-// Bitmaps for toolbar
-wxBitmap *ToolbarLoadBitmap = NULL;
-wxBitmap *ToolbarSaveBitmap = NULL;
-wxBitmap *ToolbarNewBitmap = NULL;
-wxBitmap *ToolbarVertBitmap = NULL;
-wxBitmap *ToolbarAlignTBitmap = NULL;
-wxBitmap *ToolbarAlignBBitmap = NULL;
-wxBitmap *ToolbarHorizBitmap = NULL;
-wxBitmap *ToolbarAlignLBitmap = NULL;
-wxBitmap *ToolbarAlignRBitmap = NULL;
-wxBitmap *ToolbarCopySizeBitmap = NULL;
-wxBitmap *ToolbarToFrontBitmap = NULL;
-wxBitmap *ToolbarToBackBitmap = NULL;
-wxBitmap *ToolbarHelpBitmap = NULL;
-
-wxBitmap *wxWinBitmap = NULL;
+wxResourceManager *wxResourceManager::sm_currentResourceManager = NULL;
#ifdef __X__
#include "bitmaps/load.xbm"
* Resource manager
*/
+wxResourceManager::wxResourceManager():
+ m_imageList(16, 16, TRUE)
+{
+ sm_currentResourceManager = this;
+ m_editorFrame = NULL;
+ m_editorPanel = NULL;
+ m_popupMenu = NULL;
+ m_editorResourceTree = NULL;
+ m_editorControlList = NULL;
+ m_editorPalette = NULL;
+ m_nameCounter = 1;
+ m_modified = FALSE;
+ m_currentFilename = "";
+ m_editorToolBar = NULL;
-wxResourceManager::wxResourceManager(void)
-{
- currentResourceManager = this;
- editorFrame = NULL;
- editorPanel = NULL;
- popupMenu = NULL;
- editorResourceList = NULL;
- editorPalette = NULL;
- nameCounter = 1;
- modified = FALSE;
- currentFilename = "";
- editMode = TRUE;
- editorToolBar = NULL;
-
// Default window positions
- resourceEditorWindowSize.width = 470;
- resourceEditorWindowSize.height = 300;
+ m_resourceEditorWindowSize.width = 470;
+ m_resourceEditorWindowSize.height = 300;
- resourceEditorWindowSize.x = 0;
- resourceEditorWindowSize.y = 0;
-
- propertyWindowSize.width = 300;
- propertyWindowSize.height = 300;
+ m_resourceEditorWindowSize.x = 0;
+ m_resourceEditorWindowSize.y = 0;
+
+ m_propertyWindowSize.width = 300;
+ m_propertyWindowSize.height = 300;
- helpInstance = NULL;
+ m_helpController = NULL;
+
+ m_bitmapImage = NULL;
+ m_rootDialogItem = 0;
}
-wxResourceManager::~wxResourceManager(void)
+wxResourceManager::~wxResourceManager()
{
- currentResourceManager = NULL;
+ sm_currentResourceManager = NULL;
SaveOptions();
- helpInstance->Quit();
- delete helpInstance;
- helpInstance = NULL;
+ if (m_helpController)
+ {
+ m_helpController->Quit();
+ delete m_helpController;
+ m_helpController = NULL;
+ }
+ delete m_bitmapImage;
+ delete m_popupMenu;
}
-bool wxResourceManager::Initialize(void)
+bool wxResourceManager::Initialize()
{
// Set up the resource filename for each platform.
#ifdef __WINDOWS__
char buf[256];
GetWindowsDirectory(buf, 256);
strcat(buf, "\\dialoged.ini");
- optionsResourceFilename = buf;
+ m_optionsResourceFilename = buf;
#elif defined(__X__)
char buf[500];
- (void)wxGetHomeDir(buf);
- strcat(buf, "/.hardyrc");
- optionsResourceFilename = buf;
+ ()wxGetHomeDir(buf);
+ strcat(buf, "/.dialogedrc");
+ m_optionsResourceFilename = buf;
#else
#error "Unsupported platform."
#endif
LoadOptions();
- helpInstance = new wxHelpController;
- helpInstance->Initialize("dialoged");
+ m_helpController = new wxHelpController;
+ m_helpController->Initialize("dialoged");
- InitializeTools();
- popupMenu = new wxMenu("", (wxFunction)ObjectMenuProc);
- popupMenu->Append(OBJECT_MENU_EDIT, "Edit properties");
- popupMenu->Append(OBJECT_MENU_DELETE, "Delete object");
-
- if (!wxWinBitmap)
+ m_popupMenu = new wxMenu("", (wxFunction)ObjectMenuProc);
+ m_popupMenu->Append(OBJECT_MENU_EDIT, "Edit properties");
+ m_popupMenu->Append(OBJECT_MENU_DELETE, "Delete object");
+
+ if (!m_bitmapImage)
{
#ifdef __WINDOWS__
- wxWinBitmap = new wxBitmap("WXWINBMP", wxBITMAP_TYPE_BMP_RESOURCE);
+ m_bitmapImage = new wxBitmap("WXWINBMP", wxBITMAP_TYPE_BMP_RESOURCE);
#endif
#ifdef __X__
- wxWinBitmap = new wxBitmap(wxwin_bits, wxwin_width, wxwin_height);
+ m_bitmapImage = new wxBitmap(wxwin_bits, wxwin_width, wxwin_height);
#endif
}
+
+ // Initialize the image list icons
+#ifdef __WINDOWS__
+ wxIcon icon1("DIALOG_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ wxIcon icon2("FOLDER1_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ wxIcon icon3("FOLDER2_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ wxIcon icon4("BUTTONSM_ICON", wxBITMAP_TYPE_ICO_RESOURCE, 16, 16);
+ m_imageList.Add(icon1);
+ m_imageList.Add(icon2);
+ m_imageList.Add(icon3);
+ m_imageList.Add(icon4);
+#endif
+
return TRUE;
}
-bool wxResourceManager::LoadOptions(void)
+bool wxResourceManager::LoadOptions()
{
- wxGetResource("DialogEd", "editorWindowX", &resourceEditorWindowSize.x, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "editorWindowY", &resourceEditorWindowSize.y, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "editorWindowWidth", &resourceEditorWindowSize.width, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "editorWindowHeight", &resourceEditorWindowSize.height, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "propertyWindowX", &propertyWindowSize.x, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "propertyWindowY", &propertyWindowSize.y, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "propertyWindowWidth", &propertyWindowSize.width, optionsResourceFilename.GetData());
- wxGetResource("DialogEd", "propertyWindowHeight", &propertyWindowSize.height, optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "editorWindowX", &m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "editorWindowY", &m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "editorWindowWidth", &m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "editorWindowHeight", &m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "propertyWindowX", &m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "propertyWindowY", &m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "propertyWindowWidth", &m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
+ wxGetResource("DialogEd", "propertyWindowHeight", &m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
return TRUE;
}
-bool wxResourceManager::SaveOptions(void)
+bool wxResourceManager::SaveOptions()
{
- wxWriteResource("DialogEd", "editorWindowX", resourceEditorWindowSize.x, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "editorWindowY", resourceEditorWindowSize.y, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "editorWindowWidth", resourceEditorWindowSize.width, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "editorWindowHeight", resourceEditorWindowSize.height, optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "editorWindowX", m_resourceEditorWindowSize.x, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "editorWindowY", m_resourceEditorWindowSize.y, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "editorWindowWidth", m_resourceEditorWindowSize.width, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "editorWindowHeight", m_resourceEditorWindowSize.height, m_optionsResourceFilename.GetData());
+
+ wxWriteResource("DialogEd", "propertyWindowX", m_propertyWindowSize.x, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "propertyWindowY", m_propertyWindowSize.y, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "propertyWindowWidth", m_propertyWindowSize.width, m_optionsResourceFilename.GetData());
+ wxWriteResource("DialogEd", "propertyWindowHeight", m_propertyWindowSize.height, m_optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "propertyWindowX", propertyWindowSize.x, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "propertyWindowY", propertyWindowSize.y, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "propertyWindowWidth", propertyWindowSize.width, optionsResourceFilename.GetData());
- wxWriteResource("DialogEd", "propertyWindowHeight", propertyWindowSize.height, optionsResourceFilename.GetData());
-
return TRUE;
}
{
if (show)
{
- if (editorFrame)
+ if (m_editorFrame)
{
- editorFrame->Iconize(FALSE);
- editorFrame->Show(TRUE);
+ m_editorFrame->Iconize(FALSE);
+ m_editorFrame->Show(TRUE);
return TRUE;
}
- editorFrame = OnCreateEditorFrame(title);
+ m_editorFrame = OnCreateEditorFrame(title);
SetFrameTitle("");
- wxMenuBar *menuBar = OnCreateEditorMenuBar(editorFrame);
- editorFrame->SetMenuBar(menuBar);
- editorPanel = OnCreateEditorPanel(editorFrame);
- editorToolBar = (EditorToolBar *)OnCreateToolBar(editorFrame);
- editorPalette = OnCreatePalette(editorFrame);
+ wxMenuBar *menuBar = OnCreateEditorMenuBar(m_editorFrame);
+ m_editorFrame->SetMenuBar(menuBar);
+
+ m_editorToolBar = (EditorToolBar *)OnCreateToolBar(m_editorFrame);
+// m_editorPalette = OnCreatePalette(m_editorFrame);
+ m_editorControlList = new wxResourceEditorControlList(m_editorFrame, IDC_LISTCTRL, wxPoint(0, 0), wxSize(-1, -1));
+ m_editorResourceTree = new wxResourceEditorProjectTree(m_editorFrame, IDC_TREECTRL, wxPoint(0, 0), wxSize(-1, -1),
+ wxTR_HAS_BUTTONS);
+ m_editorPanel = OnCreateEditorPanel(m_editorFrame);
+
+ m_editorResourceTree->SetImageList(& m_imageList);
// Constraints for toolbar
wxLayoutConstraints *c = new wxLayoutConstraints;
- c->left.SameAs (editorFrame, wxLeft, 0);
- c->top.SameAs (editorFrame, wxTop, 0);
- c->right.SameAs (editorFrame, wxRight, 0);
- c->bottom.Unconstrained();
+ c->left.SameAs (m_editorFrame, wxLeft, 0);
+ c->top.SameAs (m_editorFrame, wxTop, 0);
+ c->right.SameAs (m_editorFrame, wxRight, 0);
+ c->bottom.Unconstrained();
c->width.Unconstrained();
c->height.Absolute(28);
- editorToolBar->SetConstraints(c);
-
+ m_editorToolBar->SetConstraints(c);
+/*
// Constraints for palette
c = new wxLayoutConstraints;
- c->left.SameAs (editorFrame, wxLeft, 0);
- c->top.SameAs (editorToolBar, wxBottom, 0);
- c->right.SameAs (editorFrame, wxRight, 0);
- c->bottom.Unconstrained();
+ c->left.SameAs (m_editorFrame, wxLeft, 0);
+ c->top.SameAs (m_editorToolBar, wxBottom, 0);
+ c->right.SameAs (m_editorFrame, wxRight, 0);
+ c->bottom.Unconstrained();
c->width.Unconstrained();
c->height.Absolute(34);
- editorPalette->SetConstraints(c);
+ m_editorPalette->SetConstraints(c);
+*/
+ // Constraints for listbox
+ c = new wxLayoutConstraints;
+ c->left.SameAs (m_editorFrame, wxLeft, 0);
+ c->top.SameAs (m_editorToolBar, wxBottom, 0);
+ c->right.Absolute (150);
+ c->bottom.SameAs (m_editorControlList, wxTop, 0);
+ c->width.Unconstrained();
+ c->height.Unconstrained();
+ m_editorResourceTree->SetConstraints(c);
// Constraints for panel
c = new wxLayoutConstraints;
- c->left.SameAs (editorFrame, wxLeft, 0);
- c->top.SameAs (editorPalette, wxBottom, 0);
- c->right.SameAs (editorFrame, wxRight, 0);
- c->bottom.SameAs (editorFrame, wxBottom, 0);
+ c->left.SameAs (m_editorResourceTree, wxRight, 0);
+ c->top.SameAs (m_editorToolBar, wxBottom, 0);
+ c->right.SameAs (m_editorFrame, wxRight, 0);
+ c->bottom.SameAs (m_editorControlList, wxTop, 0);
c->width.Unconstrained();
c->height.Unconstrained();
- editorPanel->SetConstraints(c);
+ m_editorPanel->SetConstraints(c);
+
+ // Constraints for control list (bottom window)
+ c = new wxLayoutConstraints;
+ c->left.SameAs (m_editorFrame, wxLeft, 0);
+ c->right.SameAs (m_editorFrame, wxRight, 0);
+ c->bottom.SameAs (m_editorFrame, wxBottom, 0);
+ c->width.Unconstrained();
+ c->height.Absolute(60);
+ m_editorControlList->SetConstraints(c);
- editorFrame->SetAutoLayout(TRUE);
+ m_editorFrame->SetAutoLayout(TRUE);
UpdateResourceList();
- editorFrame->Show(TRUE);
+
+ m_editorFrame->Show(TRUE);
return TRUE;
}
else
{
- wxFrame *fr = editorFrame;
- if (editorFrame->OnClose())
+ wxFrame *fr = m_editorFrame;
+ if (m_editorFrame->OnClose())
{
fr->Show(FALSE);
delete fr;
- editorFrame = NULL;
- editorPanel = NULL;
+ m_editorFrame = NULL;
+ m_editorPanel = NULL;
}
}
return TRUE;
void wxResourceManager::SetFrameTitle(const wxString& filename)
{
- if (editorFrame)
+ if (m_editorFrame)
{
if (filename == wxString(""))
- editorFrame->SetTitle("wxWindows Dialog Editor - untitled");
+ m_editorFrame->SetTitle("wxWindows Dialog Editor - untitled");
else
{
wxString str("wxWindows Dialog Editor - ");
wxString str2(wxFileNameFromPath(WXSTRINGCAST filename));
str += str2;
- editorFrame->SetTitle(str);
+ m_editorFrame->SetTitle(str);
}
}
}
-bool wxResourceManager::Save(void)
+bool wxResourceManager::Save()
{
- if (currentFilename == wxString(""))
+ if (m_currentFilename == wxString(""))
return SaveAs();
else
- return Save(currentFilename);
+ return Save(m_currentFilename);
}
bool wxResourceManager::Save(const wxString& filename)
{
// Ensure all visible windows are saved to their resources
- currentFilename = filename;
- SetFrameTitle(currentFilename);
+ m_currentFilename = filename;
+ SetFrameTitle(m_currentFilename);
InstantiateAllResourcesFromWindows();
- if (resourceTable.Save(filename))
+ if (m_resourceTable.Save(filename))
{
Modify(FALSE);
return TRUE;
return FALSE;
}
-bool wxResourceManager::SaveAs(void)
+bool wxResourceManager::SaveAs()
{
- wxString s(wxFileSelector("Save resource file", wxPathOnly(WXSTRINGCAST currentFilename), wxFileNameFromPath(WXSTRINGCAST currentFilename),
+ wxString s(wxFileSelector("Save resource file", wxPathOnly(WXSTRINGCAST m_currentFilename), wxFileNameFromPath(WXSTRINGCAST m_currentFilename),
"wxr", "*.wxr", wxSAVE | wxOVERWRITE_PROMPT));
if (s.IsNull() || s == "")
return FALSE;
- currentFilename = s;
- Save(currentFilename);
+ m_currentFilename = s;
+ Save(m_currentFilename);
return TRUE;
}
-bool wxResourceManager::SaveIfModified(void)
+bool wxResourceManager::SaveIfModified()
{
if (Modified())
return Save();
return FALSE;
}
- if (!resourceTable.ParseResourceFile(WXSTRINGCAST str))
+ if (!m_resourceTable.ParseResourceFile(WXSTRINGCAST str))
{
wxMessageBox("Could not read file.", "Resource file load error", wxOK | wxICON_EXCLAMATION);
return FALSE;
}
- currentFilename = str;
-
- SetFrameTitle(currentFilename);
-
+ m_currentFilename = str;
+
+ SetFrameTitle(m_currentFilename);
+
UpdateResourceList();
}
else
{
SetFrameTitle("");
- currentFilename = "";
+ m_currentFilename = "";
}
Modify(FALSE);
Modify(FALSE);
}
- DisassociateWindows(deleteWindows);
+ ClearCurrentDialog();
+ DisassociateWindows();
- resourceTable.ClearTable();
+ m_resourceTable.ClearTable();
UpdateResourceList();
return TRUE;
}
-bool wxResourceManager::DisassociateWindows(bool deleteWindows)
+bool wxResourceManager::DisassociateWindows()
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
- DisassociateResource(res, deleteWindows);
+ DisassociateResource(res);
}
return TRUE;
void wxResourceManager::AssociateResource(wxItemResource *resource, wxWindow *win)
{
- if (!resourceAssociations.Get((long)resource))
- resourceAssociations.Put((long)resource, win);
-
+ if (!m_resourceAssociations.Get((long)resource))
+ m_resourceAssociations.Put((long)resource, win);
+
wxNode *node = resource->GetChildren().First();
while (node)
{
wxItemResource *child = (wxItemResource *)node->Data();
- wxWindow *childWindow = (wxWindow *)resourceAssociations.Get((long)child);
+ wxWindow *childWindow = (wxWindow *)m_resourceAssociations.Get((long)child);
if (!childWindow)
childWindow = win->FindWindow(child->GetName());
if (childWindow)
}
}
-bool wxResourceManager::DisassociateResource(wxItemResource *resource, bool deleteWindow)
+bool wxResourceManager::DisassociateResource(wxItemResource *resource)
{
wxWindow *win = FindWindowForResource(resource);
if (!win)
return FALSE;
- // Disassociate children of window without deleting windows
- // since they'll be deleted by parent.
+ // Disassociate children of window
if (win->GetChildren())
{
wxNode *node = win->GetChildren()->First();
{
wxWindow *child = (wxWindow *)node->Data();
if (child->IsKindOf(CLASSINFO(wxControl)))
- DisassociateResource(child, FALSE);
+ DisassociateResource(child);
node = node->Next();
}
}
- if (deleteWindow)
- {
- if (win->IsKindOf(CLASSINFO(wxPanel)) && !win->IsKindOf(CLASSINFO(wxDialog)))
- delete win->GetParent(); // Delete frame
- else if ( win->IsKindOf(CLASSINFO(wxControl)) )
- {
- wxEvtHandler *childHandler = win->GetEventHandler();
- if ( childHandler != win )
- {
- win->PopEventHandler();
- delete childHandler;
- }
- delete win;
- }
- else
- // Is this enough? What about event handler? TODO
- delete win;
- }
RemoveSelection(win);
- resourceAssociations.Delete((long)resource);
+ m_resourceAssociations.Delete((long)resource);
return TRUE;
}
-bool wxResourceManager::DisassociateResource(wxWindow *win, bool deleteWindow)
+bool wxResourceManager::DisassociateResource(wxWindow *win)
{
wxItemResource *res = FindResourceForWindow(win);
if (res)
- return DisassociateResource(res, deleteWindow);
- return FALSE;
+ return DisassociateResource(res);
+ else
+ return FALSE;
+}
+
+// Saves the window info into the resource, and deletes the
+// handler. Doesn't actually disassociate the window from
+// the resources. Replaces OnClose.
+bool wxResourceManager::SaveInfoAndDeleteHandler(wxWindow* win)
+{
+ wxItemResource *res = FindResourceForWindow(win);
+
+ if (win->IsKindOf(CLASSINFO(wxPanel)))
+ {
+ wxResourceEditorDialogHandler* handler = (wxResourceEditorDialogHandler*) win->GetEventHandler();
+ win->PopEventHandler();
+
+ // Now reset all child event handlers
+ wxNode *node = win->GetChildren()->First();
+ while ( node )
+ {
+ wxWindow *child = (wxWindow *)node->Data();
+ wxEvtHandler *childHandler = child->GetEventHandler();
+ if ( child->IsKindOf(CLASSINFO(wxControl)) && childHandler != child )
+ {
+ child->PopEventHandler(TRUE);
+ }
+ node = node->Next();
+ }
+ delete handler;
+ }
+ else
+ {
+ win->PopEventHandler(TRUE);
+ }
+
+ // Save the information
+ InstantiateResourceFromWindow(res, win, TRUE);
+
+// DisassociateResource(win);
+
+ return TRUE;
+}
+
+// Destroys the window. If this is the 'current' panel, NULLs the
+// variable.
+bool wxResourceManager::DeleteWindow(wxWindow* win)
+{
+ if (m_editorPanel->m_childWindow == win)
+ m_editorPanel->m_childWindow = NULL;
+
+ win->Destroy();
+ return TRUE;
}
wxItemResource *wxResourceManager::FindResourceForWindow(wxWindow *win)
{
- resourceAssociations.BeginFind();
+ m_resourceAssociations.BeginFind();
wxNode *node;
- while (node = resourceAssociations.Next())
+ while (node = m_resourceAssociations.Next())
{
wxWindow *w = (wxWindow *)node->Data();
if (w == win)
wxWindow *wxResourceManager::FindWindowForResource(wxItemResource *resource)
{
- return (wxWindow *)resourceAssociations.Get((long)resource);
+ return (wxWindow *)m_resourceAssociations.Get((long)resource);
}
{
while (TRUE)
{
- sprintf(buf, "%s%d", prefix, nameCounter);
- nameCounter ++;
-
- if (!resourceTable.FindResource(buf))
+ sprintf(buf, "%s%d", prefix, m_nameCounter);
+ m_nameCounter ++;
+
+ if (!m_resourceTable.FindResource(buf))
return;
}
}
int frameWidth = 420;
int frameHeight = 300;
- wxResourceEditorFrame *frame = new wxResourceEditorFrame(this, NULL, (char *)title,
-
- resourceEditorWindowSize.x, resourceEditorWindowSize.y,
- resourceEditorWindowSize.width, resourceEditorWindowSize.height,
+ wxResourceEditorFrame *frame = new wxResourceEditorFrame(this, NULL, title,
+ wxPoint(m_resourceEditorWindowSize.x, m_resourceEditorWindowSize.y),
+ wxSize(m_resourceEditorWindowSize.width, m_resourceEditorWindowSize.height),
+ wxDEFAULT_FRAME_STYLE);
- wxDEFAULT_FRAME);
+ frame->CreateStatusBar(1);
- wxFrame::UseNativeStatusBar(FALSE);
-
- frame->CreateStatusBar(2);
-
- wxFrame::UseNativeStatusBar(TRUE);
-
- frame->SetStatusText(editMode ? "Edit mode" : "Test mode", 1);
frame->SetAutoLayout(TRUE);
#ifdef __WINDOWS__
wxIcon *icon = new wxIcon("DIALOGEDICON");
wxMenu *fileMenu = new wxMenu;
fileMenu->Append(RESED_NEW_DIALOG, "New &dialog", "Create a new dialog");
- fileMenu->Append(RESED_NEW_PANEL, "New &panel", "Create a new panel");
fileMenu->AppendSeparator();
fileMenu->Append(wxID_NEW, "&New project", "Clear the current project");
fileMenu->Append(wxID_OPEN, "&Open...", "Load a resource file");
fileMenu->Append(wxID_EXIT, "E&xit", "Exit resource editor");
wxMenu *editMenu = new wxMenu;
+ editMenu->Append(RESED_TEST, "&Test Dialog", "Test dialog");
editMenu->Append(RESED_RECREATE, "&Recreate", "Recreate the selected resource(s)");
editMenu->Append(RESED_DELETE, "&Delete", "Delete the selected resource(s)");
- editMenu->AppendSeparator();
- editMenu->Append(RESED_TOGGLE_TEST_MODE, "&Toggle edit/test mode", "Toggle edit/test mode");
wxMenu *helpMenu = new wxMenu;
helpMenu->Append(RESED_CONTENTS, "&Help topics", "Invokes the on-line help");
return menuBar;
}
-wxPanel *wxResourceManager::OnCreateEditorPanel(wxFrame *parent)
+wxResourceEditorScrolledWindow *wxResourceManager::OnCreateEditorPanel(wxFrame *parent)
{
- wxResourceEditorPanel *panel = new wxResourceEditorPanel(parent);
-
- editorResourceList = new wxListBox(panel, -1, wxPoint(0, 0), wxSize(-1, -1));
+ wxResourceEditorScrolledWindow *panel = new wxResourceEditorScrolledWindow(parent, wxDefaultPosition, wxDefaultSize,
+// wxSUNKEN_BORDER|wxCLIP_CHILDREN);
+ wxSUNKEN_BORDER);
- wxLayoutConstraints *c = new wxLayoutConstraints;
- c->left.SameAs (panel, wxLeft, 5);
- c->top.SameAs (panel, wxTop, 5);
- c->right.SameAs (panel, wxRight, 5);
- c->bottom.SameAs (panel, wxBottom, 5);
- c->width.Unconstrained();
- c->height.Unconstrained();
- editorResourceList->SetConstraints(c);
+ panel->SetScrollbars(10, 10, 100, 100);
return panel;
}
{
// Load palette bitmaps
#ifdef __WINDOWS__
- ToolbarLoadBitmap = new wxBitmap("LOADTOOL");
- ToolbarSaveBitmap = new wxBitmap("SAVETOOL");
- ToolbarNewBitmap = new wxBitmap("NEWTOOL");
- ToolbarVertBitmap = new wxBitmap("VERTTOOL");
- ToolbarAlignTBitmap = new wxBitmap("ALIGNTTOOL");
- ToolbarAlignBBitmap = new wxBitmap("ALIGNBTOOL");
- ToolbarHorizBitmap = new wxBitmap("HORIZTOOL");
- ToolbarAlignLBitmap = new wxBitmap("ALIGNLTOOL");
- ToolbarAlignRBitmap = new wxBitmap("ALIGNRTOOL");
- ToolbarCopySizeBitmap = new wxBitmap("COPYSIZETOOL");
- ToolbarToBackBitmap = new wxBitmap("TOBACKTOOL");
- ToolbarToFrontBitmap = new wxBitmap("TOFRONTTOOL");
- ToolbarHelpBitmap = new wxBitmap("HELPTOOL");
+ wxBitmap ToolbarLoadBitmap("LOADTOOL");
+ wxBitmap ToolbarSaveBitmap("SAVETOOL");
+ wxBitmap ToolbarNewBitmap("NEWTOOL");
+ wxBitmap ToolbarVertBitmap("VERTTOOL");
+ wxBitmap ToolbarAlignTBitmap("ALIGNTTOOL");
+ wxBitmap ToolbarAlignBBitmap("ALIGNBTOOL");
+ wxBitmap ToolbarHorizBitmap("HORIZTOOL");
+ wxBitmap ToolbarAlignLBitmap("ALIGNLTOOL");
+ wxBitmap ToolbarAlignRBitmap("ALIGNRTOOL");
+ wxBitmap ToolbarCopySizeBitmap("COPYSIZETOOL");
+ wxBitmap ToolbarToBackBitmap("TOBACKTOOL");
+ wxBitmap ToolbarToFrontBitmap("TOFRONTTOOL");
+ wxBitmap ToolbarHelpBitmap("HELPTOOL");
#endif
#ifdef __X__
- ToolbarLoadBitmap = new wxBitmap(load_bits, load_width, load_height);
- ToolbarSaveBitmap = new wxBitmap(save_bits, save_width, save_height);
- ToolbarNewBitmap = new wxBitmap(new_bits, save_width, save_height);
- ToolbarVertBitmap = new wxBitmap(vert_bits, vert_width, vert_height);
- ToolbarAlignTBitmap = new wxBitmap(alignt_bits, alignt_width, alignt_height);
- ToolbarAlignBBitmap = new wxBitmap(alignb_bits, alignb_width, alignb_height);
- ToolbarHorizBitmap = new wxBitmap(horiz_bits, horiz_width, horiz_height);
- ToolbarAlignLBitmap = new wxBitmap(alignl_bits, alignl_width, alignl_height);
- ToolbarAlignRBitmap = new wxBitmap(alignr_bits, alignr_width, alignr_height);
- ToolbarCopySizeBitmap = new wxBitmap(copysize_bits, copysize_width, copysize_height);
- ToolbarToBackBitmap = new wxBitmap(toback_bits, toback_width, toback_height);
- ToolbarToFrontBitmap = new wxBitmap(tofront_bits, tofront_width, tofront_height);
-// ToolbarCPPBitmap = new wxBitmap(cpp_bits, cpp_width, cpp_height);
-// ToolbarTreeBitmap = new wxBitmap(tree_bits, tree_width, tree_height);
- ToolbarHelpBitmap = new wxBitmap(help_bits, help_width, help_height);
+ wxBitmap ToolbarLoadBitmap(load_bits, load_width, load_height);
+ wxBitmap ToolbarSaveBitmap(save_bits, save_width, save_height);
+ wxBitmap ToolbarNewBitmap(new_bits, save_width, save_height);
+ wxBitmap ToolbarVertBitmap(vert_bits, vert_width, vert_height);
+ wxBitmap ToolbarAlignTBitmap(alignt_bits, alignt_width, alignt_height);
+ wxBitmap ToolbarAlignBBitmap(alignb_bits, alignb_width, alignb_height);
+ wxBitmap ToolbarHorizBitmap(horiz_bits, horiz_width, horiz_height);
+ wxBitmap ToolbarAlignLBitmap(alignl_bits, alignl_width, alignl_height);
+ wxBitmap ToolbarAlignRBitmap(alignr_bits, alignr_width, alignr_height);
+ wxBitmap ToolbarCopySizeBitmap(copysize_bits, copysize_width, copysize_height);
+ wxBitmap ToolbarToBackBitmap(toback_bits, toback_width, toback_height);
+ wxBitmap ToolbarToFrontBitmap(tofront_bits, tofront_width, tofront_height);
+ wxBitmap ToolbarHelpBitmap(help_bits, help_width, help_height);
#endif
// Create the toolbar
- EditorToolBar *toolbar = new EditorToolBar(parent, 0, 0, -1, -1, wxNO_BORDER,
+ EditorToolBar *toolbar = new EditorToolBar(parent, wxPoint(0, 0), wxSize(-1, -1), wxNO_BORDER,
wxVERTICAL, 1);
toolbar->SetMargins(2, 2);
// toolbar->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, (wxBitmap *)NULL,
FALSE, (float)currentX, -1, NULL, "To back");
currentX += width + dx + gap;
-/*
- toolbar->AddTool(TOOLBAR_GEN_CPP, ToolbarCPPBitmap, (wxBitmap *)NULL,
- FALSE, (float)currentX, -1, NULL);
- currentX += width + dx;
- toolbar->AddTool(TOOLBAR_TREE, ToolbarTreeBitmap, (wxBitmap *)NULL,
- FALSE, (float)currentX, -1, NULL);
- currentX += width + dx;
-*/
toolbar->AddSeparator();
toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, (wxBitmap *)NULL,
FALSE, (float)currentX, -1, NULL, "Help");
// parent->OnSize(-1, -1);
}
-void wxResourceManager::UpdateResourceList(void)
+void wxResourceManager::UpdateResourceList()
{
- editorResourceList->Clear();
- resourceTable.BeginFind();
+ if (!m_editorResourceTree)
+ return;
+
+ m_editorResourceTree->SetInvalid(TRUE);
+ m_editorResourceTree->DeleteAllItems();
+
+ long id = m_editorResourceTree->InsertItem(0, "Dialogs"
+#ifdef __WINDOWS__
+ , 1, 2
+#endif
+ );
+
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
wxString resType(res->GetType());
-// if (res->GetType() == wxTYPE_DIALOG_BOX || res->GetType() == wxTYPE_FRAME || res->GetType() == wxTYPE_BITMAP)
if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel" || resType == "wxBitmap")
{
- AddItemsRecursively(0, res);
+ AddItemsRecursively(id, res);
}
}
+ m_editorResourceTree->ExpandItem(id, wxTREE_EXPAND_EXPAND);
+ m_editorResourceTree->SetInvalid(FALSE);
}
-void wxResourceManager::AddItemsRecursively(int level, wxItemResource *resource)
+void wxResourceManager::AddItemsRecursively(long parent, wxItemResource *resource)
{
- int padWidth = level*4;
-
wxString theString("");
- theString.Append(' ', padWidth);
- theString += resource->GetName();
+ theString = resource->GetName();
+
+ int imageId = 0;
+ wxString resType(resource->GetType());
+ if (resType == "wxDialog" || resType == "wxDialogBox" || resType == "wxPanel")
+ imageId = 0;
+ else
+ imageId = 3;
- editorResourceList->Append(theString.GetData(), (char *)resource);
+ long id = m_editorResourceTree->InsertItem(parent, theString
+#ifdef __WINDOWS__
+ , imageId
+#endif
+ );
+
+ m_editorResourceTree->SetItemData(id, (long) resource);
if (strcmp(resource->GetType(), "wxBitmap") != 0)
{
while (node)
{
wxItemResource *res = (wxItemResource *)node->Data();
- AddItemsRecursively(level+1, res);
+ AddItemsRecursively(id, res);
node = node->Next();
}
}
+ m_editorResourceTree->ExpandItem(id, wxTREE_EXPAND_EXPAND);
}
-bool wxResourceManager::EditSelectedResource(void)
+bool wxResourceManager::EditSelectedResource()
{
- int sel = editorResourceList->GetSelection();
+ int sel = m_editorResourceTree->GetSelection();
if (sel > -1)
{
- wxItemResource *res = (wxItemResource *)editorResourceList->wxListBox::GetClientData(sel);
+ wxItemResource *res = (wxItemResource *)m_editorResourceTree->GetItemData(sel);
return Edit(res);
}
return FALSE;
bool wxResourceManager::Edit(wxItemResource *res)
{
+ ClearCurrentDialog();
+
wxString resType(res->GetType());
- if (resType == "wxDialog" || resType == "wxDialogBox")
- {
- wxDialog *dialog = (wxDialog *)FindWindowForResource(res);
- if (dialog)
- dialog->Show(TRUE);
- else
- {
- dialog = new wxDialog;
- wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(dialog, res, dialog->GetEventHandler(),
- this);
- dialog->PushEventHandler(handler);
+ wxPanel *panel = (wxPanel *)FindWindowForResource(res);
-// dialog->SetUserEditMode(TRUE);
-
- dialog->LoadFromResource(GetEditorFrame(), res->GetName(), &resourceTable);
- handler->AddChildHandlers(); // Add event handlers for all controls
- dialog->SetModal(FALSE);
- AssociateResource(res, dialog);
- dialog->Show(TRUE);
- }
- }
- else if (resType == "wxPanel")
- {
- wxPanel *panel = (wxPanel *)FindWindowForResource(res);
- if (panel)
- panel->GetParent()->Show(TRUE);
- else
- {
- DialogEditorPanelFrame *frame = new DialogEditorPanelFrame(GetEditorFrame(), res->GetName(), 10, 10, 400, 300, wxDEFAULT_FRAME_STYLE, res->GetName());
+ if (panel)
+ {
+ wxMessageBox("Should not find panel in wxResourceManager::Edit");
+ return FALSE;
+ }
+ else
+ {
+ long style = res->GetStyle();
+ res->SetStyle(style|wxRAISED_BORDER);
panel = new wxPanel;
wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(panel, res, panel->GetEventHandler(),
this);
- panel->PushEventHandler(handler);
-// panel->SetUserEditMode(TRUE);
-
- panel->LoadFromResource(frame, res->GetName(), &resourceTable);
- handler->AddChildHandlers(); // Add event handlers for all controls
- AssociateResource(res, panel);
- frame->SetClientSize(res->GetWidth(), res->GetHeight());
- frame->Show(TRUE);
- }
- }
- return FALSE;
-}
-bool wxResourceManager::CreateNewDialog(void)
-{
- char buf[256];
- MakeUniqueName("dialog", buf);
-
- wxItemResource *resource = new wxItemResource;
-// resource->SetType(wxTYPE_DIALOG_BOX);
- resource->SetType("wxDialog");
- resource->SetName(buf);
- resource->SetTitle(buf);
- resourceTable.AddResource(resource);
+ panel->LoadFromResource(m_editorPanel, res->GetName(), &m_resourceTable);
-#ifdef __MOTIF__
- wxDialog *dialog = new wxDialog(GetEditorFrame(), -1, buf, wxPoint(10, 10), wxSize(400, 300), wxDEFAULT_DIALOG_STYLE, buf);
-/*
- dialog->SetBackgroundColour(*wxLIGHT_GREY);
- dialog->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
- dialog->SetButtonColour(*wxBLACK);
- dialog->SetLabelColour(*wxBLACK);
-*/
-#else
- wxDialog *dialog = new wxDialog(GetEditorFrame(), -1, buf, wxPoint(10, 10), wxSize(400, 300), wxDEFAULT_DIALOG_STYLE, buf);
-#endif
-
- resource->SetValue1(FALSE); // Modeless to start with
- resource->SetStyle(dialog->GetWindowStyleFlag());
-
- // For editing in situ we will need to use the hash table to ensure
- // we don't dereference invalid pointers.
-// resourceWindowTable.Put((long)resource, dialog);
-
- wxResourceEditorDialogHandler *handler = new wxResourceEditorDialogHandler(dialog, resource, dialog->GetEventHandler(),
- this);
+ panel->PushEventHandler(handler);
- dialog->PushEventHandler(handler);
-
- dialog->Centre(wxBOTH);
-// dialog->SetUserEditMode(TRUE);
- dialog->Show(TRUE);
+ res->SetStyle(style);
+ handler->AddChildHandlers(); // Add event handlers for all controls
+ AssociateResource(res, panel);
- SetEditMode(TRUE, FALSE);
+ m_editorPanel->m_childWindow = panel;
+ panel->Move(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY());
+ panel->Show(TRUE);
+ panel->Refresh();
- AssociateResource(resource, dialog);
-// SetCurrentResource(resource);
-// SetCurrentResourceWindow(dialog);
- UpdateResourceList();
-
- Modify(TRUE);
-
- return TRUE;
+ wxClientDC dc(m_editorPanel);
+ m_editorPanel->DrawTitle(dc);
+ }
+ return FALSE;
}
-bool wxResourceManager::CreateNewPanel(void)
+bool wxResourceManager::CreateNewPanel()
{
+ ClearCurrentDialog();
+
char buf[256];
MakeUniqueName("panel", buf);
resource->SetType("wxPanel");
resource->SetName(buf);
resource->SetTitle(buf);
- resourceTable.AddResource(resource);
-
- DialogEditorPanelFrame *frame = new DialogEditorPanelFrame(GetEditorFrame(), buf, 10, 10, 400, 300, wxDEFAULT_FRAME_STYLE, buf);
+ m_resourceTable.AddResource(resource);
-#ifdef __MOTIF__
- wxPanel *panel = new wxPanel(frame, -1, wxPoint(0, 0), wxSize(400, 300), 0, buf);
-/*
- panel->SetBackgroundColour(*wxLIGHT_GREY);
- panel->GetDC()->SetBackground(wxLIGHT_GREY_BRUSH);
- panel->SetButtonColour(*wxBLACK);
- panel->SetLabelColour(*wxBLACK);
-*/
+ wxPanel *panel = new wxPanel(m_editorPanel, -1,
+ wxPoint(m_editorPanel->GetMarginX(), m_editorPanel->GetMarginY()),
+ wxSize(400, 300), wxRAISED_BORDER, buf);
+ m_editorPanel->m_childWindow = panel;
-#else
- wxPanel *panel = new wxPanel(frame, -1, wxPoint(0, 0), wxSize(400, 300), 0, buf);
-#endif
-
- resource->SetStyle(panel->GetWindowStyleFlag());
+ resource->SetStyle(0); // panel->GetWindowStyleFlag());
+ resource->SetSize(10, 10, 400, 300);
// For editing in situ we will need to use the hash table to ensure
// we don't dereference invalid pointers.
this);
panel->PushEventHandler(handler);
- panel->Centre(wxBOTH);
-// panel->SetUserEditMode(TRUE);
- frame->Show(TRUE);
-
- SetEditMode(TRUE, FALSE);
-
AssociateResource(resource, panel);
-// SetCurrentResource(resource);
-// SetCurrentResourceWindow(panel);
UpdateResourceList();
Modify(TRUE);
-
+ m_editorPanel->m_childWindow->Refresh();
+
+// panel->Refresh();
+
+ wxClientDC dc(m_editorPanel);
+ m_editorPanel->DrawTitle(dc);
+
return TRUE;
}
MakeUniqueName("button", buf);
res->SetName(buf);
if (isBitmap)
- newItem = new wxBitmapButton(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
+ newItem = new wxBitmapButton(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
else
newItem = new wxButton(panel, -1, "Button", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
}
{
MakeUniqueName("button", buf);
res->SetName(buf);
- newItem = new wxBitmapButton(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
+ newItem = new wxBitmapButton(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
}
else if (itemType == "wxMessage" || itemType == "wxStaticText")
{
MakeUniqueName("message", buf);
res->SetName(buf);
if (isBitmap)
- newItem = new wxStaticBitmap(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(0, 0), 0, buf);
+ newItem = new wxStaticBitmap(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(0, 0), 0, buf);
else
newItem = new wxStaticText(panel, -1, "Message", wxPoint(x, y), wxSize(-1, -1), 0, buf);
}
{
MakeUniqueName("message", buf);
res->SetName(buf);
- newItem = new wxStaticBitmap(panel, -1, wxWinBitmap, wxPoint(x, y), wxSize(-1, -1), 0, buf);
+ newItem = new wxStaticBitmap(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, buf);
}
else if (itemType == "wxCheckBox")
{
res->SetName(buf);
newItem = new wxSlider(panel, -1, 1, 1, 10, wxPoint(x, y), wxSize(120, -1), wxHORIZONTAL, wxDefaultValidator, buf);
}
- else if (itemType == "wxText" || itemType == "wxTextCtrl")
+ else if (itemType == "wxText" || itemType == "wxTextCtrl (single-line)")
{
- MakeUniqueName("text", buf);
+ MakeUniqueName("textctrl", buf);
res->SetName(buf);
+ res->SetType("wxTextCtrl");
newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, -1), 0, wxDefaultValidator, buf);
}
-/*
- else if (itemType == "wxMultiText")
+ else if (itemType == "wxMultiText" || itemType == "wxTextCtrl (multi-line)")
{
- MakeUniqueName("multitext", buf);
+ MakeUniqueName("textctrl", buf);
res->SetName(buf);
- newItem = new wxMultiText(panel, (wxFunction)NULL, "Multitext", "", x, y, -1, -1, 0, wxDefaultValidator, buf);
+ res->SetType("wxTextCtrl");
+ newItem = new wxTextCtrl(panel, -1, "", wxPoint(x, y), wxSize(120, 100), wxTE_MULTILINE, wxDefaultValidator, buf);
}
-*/
else if (itemType == "wxScrollBar")
{
MakeUniqueName("scrollbar", buf);
return TRUE;
}
+void wxResourceManager::ClearCurrentDialog()
+{
+ if (m_editorPanel->m_childWindow)
+ {
+ SaveInfoAndDeleteHandler(m_editorPanel->m_childWindow);
+ DisassociateResource(m_editorPanel->m_childWindow);
+ DeleteWindow(m_editorPanel->m_childWindow);
+ m_editorPanel->m_childWindow = NULL;
+ m_editorPanel->Clear();
+ }
+}
+
// Find the first dialog or panel for which
// there is a selected panel item.
-wxWindow *wxResourceManager::FindParentOfSelection(void)
+wxWindow *wxResourceManager::FindParentOfSelection()
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
wxWindow *win = FindWindowForResource(res);
}
// Copy the first image's size to subsequent images
-void wxResourceManager::CopySize(void)
+void wxResourceManager::CopySize()
{
wxWindow *win = FindParentOfSelection();
if (!win)
void wxResourceManager::AddSelection(wxWindow *win)
{
- if (!selections.Member(win))
- selections.Append(win);
+ if (!m_selections.Member(win))
+ m_selections.Append(win);
}
void wxResourceManager::RemoveSelection(wxWindow *win)
{
- selections.DeleteObject(win);
+ m_selections.DeleteObject(win);
}
// Need to search through resource table removing this from
// any resource which has this as a parent.
bool wxResourceManager::RemoveResourceFromParent(wxItemResource *res)
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *thisRes = (wxItemResource *)node->Data();
if (thisRes->GetChildren().Member(res))
// associate bitmap resource if not being used.
wxString resType(res->GetType());
- if ((resType == "wxMessage" || resType == "wxButton") && res->GetValue4())
+ if ((resType == "wxMessage" || resType == "wxStaticBitmap" || resType == "wxButton" || resType == "wxBitmapButton") && res->GetValue4())
{
PossiblyDeleteBitmapResource(res->GetValue4());
}
- resourceTable.Delete(res->GetName());
+ m_resourceTable.Delete(res->GetName());
delete res;
Modify(TRUE);
return TRUE;
}
-bool wxResourceManager::DeleteResource(wxWindow *win, bool deleteWindow)
+bool wxResourceManager::DeleteResource(wxWindow *win)
{
if (win->IsKindOf(CLASSINFO(wxControl)))
{
wxItemResource *res = FindResourceForWindow(win);
- DisassociateResource(res, deleteWindow);
+ DisassociateResource(res);
DeleteResource(res);
UpdateResourceList();
- // What about associated event handler? Must clean up! BUGBUG
-// if (win && deleteWindow)
-// delete win;
return TRUE;
}
child->SetSize(0,0,0,0);
resource->GetChildren().Append(child);
- resourceTable.AddResource(resource);
+ m_resourceTable.AddResource(resource);
UpdateResourceList();
}
{
if (!IsBitmapResourceUsed(resourceName))
{
- wxItemResource *res = resourceTable.FindResource(resourceName);
+ wxItemResource *res = m_resourceTable.FindResource(resourceName);
DeleteResource(res);
UpdateResourceList();
}
bool wxResourceManager::IsBitmapResourceUsed(char *resourceName)
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
wxString resType(res->GetType());
{
if (!resource || !resource->GetValue4())
return NULL;
- wxItemResource *bitmapResource = resourceTable.FindResource(resource->GetValue4());
+ wxItemResource *bitmapResource = m_resourceTable.FindResource(resource->GetValue4());
if (!bitmapResource)
return NULL;
wxItemResource *wxResourceManager::FindBitmapResourceByFilename(char *filename)
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
wxString resType(res->GetType());
wxWindowPropertyInfo *newInfo = NULL;
if (!info)
{
- newInfo = wxCreatePropertyInfoForWindow(win);
+ newInfo = CreatePropertyInfoForWindow(win);
info = newInfo;
}
if (win->IsKindOf(CLASSINFO(wxPanel)))
{
- bool isDialog = win->IsKindOf(CLASSINFO(wxDialog));
- wxWindow *parent = win->GetParent();
-
- win->GetEventHandler()->OnClose();
-
- if (!isDialog && parent)
- {
- // Delete frame parent of panel if this is not a dialog box
- parent->Close(TRUE);
- }
-
Edit(resource);
newWin = FindWindowForResource(resource);
}
else
{
- DisassociateResource(resource, FALSE);
- delete win;
- newWin = resourceTable.CreateItem((wxPanel *)parent, resource);
+ DisassociateResource(resource);
+ DeleteWindow(win);
+ newWin = m_resourceTable.CreateItem((wxPanel *)parent, resource);
AssociateResource(resource, newWin);
UpdateResourceList();
}
}
// Delete resource highlighted in the listbox
-bool wxResourceManager::DeleteSelection(bool deleteWindow)
+bool wxResourceManager::DeleteSelection()
{
- int sel = editorResourceList->GetSelection();
+ int sel = m_editorResourceTree->GetSelection();
if (sel > -1)
{
- wxItemResource *res = (wxItemResource *)editorResourceList->wxListBox::GetClientData(sel);
+ wxItemResource *res = (wxItemResource *)m_editorResourceTree->GetItemData(sel);
wxWindow *win = FindWindowForResource(res);
-/*
- if (res == currentResource)
+ if (win)
{
- currentResource = NULL;
- currentResourceWindow = NULL;
+ DeleteResource(win);
+ DeleteWindow(win);
+ UpdateResourceList();
+ Modify(TRUE);
}
-*/
-
- DisassociateResource(res, deleteWindow);
- DeleteResource(res);
- UpdateResourceList();
-
-/*
- // What about associated event handler? Must clean up! BUGBUG
- if (win && deleteWindow)
- delete win;
-*/
-
- Modify(TRUE);
+ return TRUE;
}
return FALSE;
}
// Delete resource highlighted in the listbox
-bool wxResourceManager::RecreateSelection(void)
+bool wxResourceManager::RecreateSelection()
{
wxNode *node = GetSelections().First();
while (node)
return FALSE;
}
-void wxResourceManager::SetEditMode(bool flag, bool changeCurrentResource)
-{
- editMode = flag;
- if (editorFrame)
- editorFrame->SetStatusText(editMode ? "Edit mode" : "Test mode", 1);
-
- // Switch mode for each dialog in the resource list
- resourceTable.BeginFind();
- wxNode *node = resourceTable.Next();
- while (node)
- {
- wxItemResource *resource = (wxItemResource *)node->Data();
- wxWindow *currentResourceWindow = FindWindowForResource(resource);
-
- if (changeCurrentResource && currentResourceWindow && (currentResourceWindow->IsKindOf(CLASSINFO(wxPanel))))
- {
- wxPanel *panel = (wxPanel *)currentResourceWindow;
- if (editMode)
- {
- // If we have already installed our own handler, don't bother editing.
- // This test will need to be changed eventually because for in-situ editing,
- // the user might have installed a different one anyway.
- wxEvtHandler *handler = panel->GetEventHandler();
- handler->SetEvtHandlerEnabled(TRUE);
- // Enable all children
- wxNode *node = panel->GetChildren()->First();
- while (node)
- {
- wxControl *item = (wxControl *)node->Data();
- if ( item->IsKindOf(CLASSINFO(wxControl)) )
- {
- wxEvtHandler *childHandler = item->GetEventHandler();
- childHandler->SetEvtHandlerEnabled(TRUE);
- }
- node = node->Next();
- }
- }
- else
- {
- wxEvtHandler *handler = panel->GetEventHandler();
- handler->SetEvtHandlerEnabled(FALSE);
- // Deselect all items on the dialog and refresh.
- wxNode *node = panel->GetChildren()->First();
- while (node)
- {
- wxControl *item = (wxControl *)node->Data();
- if (item->IsKindOf(CLASSINFO(wxControl)))
- {
- wxResourceEditorControlHandler *childHandler = (wxResourceEditorControlHandler *)item->GetEventHandler();
- childHandler->SetEvtHandlerEnabled(FALSE);
- childHandler->SelectItem(FALSE);
- }
- node = node->Next();
- }
- panel->Refresh();
- }
- }
- node = resourceTable.Next();
- }
-}
-
// Ensures that all currently shown windows are saved to resources,
// e.g. just before writing to a .wxr file.
-bool wxResourceManager::InstantiateAllResourcesFromWindows(void)
+bool wxResourceManager::InstantiateAllResourcesFromWindows()
{
- resourceTable.BeginFind();
+ m_resourceTable.BeginFind();
wxNode *node;
- while (node = resourceTable.Next())
+ while (node = m_resourceTable.Next())
{
wxItemResource *res = (wxItemResource *)node->Data();
wxString resType(res->GetType());
bool wxResourceManager::InstantiateResourceFromWindow(wxItemResource *resource, wxWindow *window, bool recurse)
{
- wxWindowPropertyInfo *info = wxCreatePropertyInfoForWindow(window);
+ wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(window);
info->SetResource(resource);
info->InstantiateResource(resource);
delete info;
return TRUE;
}
+// Create a window information object for the give window
+wxWindowPropertyInfo *wxResourceManager::CreatePropertyInfoForWindow(wxWindow *win)
+{
+ wxWindowPropertyInfo *info = NULL;
+ if (win->IsKindOf(CLASSINFO(wxScrollBar)))
+ {
+ info = new wxScrollBarPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxStaticBox)))
+ {
+ info = new wxGroupBoxPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxCheckBox)))
+ {
+ info = new wxCheckBoxPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxSlider)))
+ {
+ info = new wxSliderPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxGauge)))
+ {
+ info = new wxGaugePropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxListBox)))
+ {
+ info = new wxListBoxPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxRadioBox)))
+ {
+ info = new wxRadioBoxPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxChoice)))
+ {
+ info = new wxChoicePropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxButton)))
+ {
+ info = new wxButtonPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxBitmapButton)))
+ {
+ info = new wxBitmapButtonPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxStaticText)))
+ {
+ info = new wxStaticTextPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxStaticBitmap)))
+ {
+ info = new wxStaticBitmapPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxTextCtrl)))
+ {
+ info = new wxTextPropertyInfo(win);
+ }
+ else if (win->IsKindOf(CLASSINFO(wxPanel)))
+ {
+ info = new wxPanelPropertyInfo(win);
+ }
+ else
+ {
+ info = new wxWindowPropertyInfo(win);
+ }
+ return info;
+}
+
+// Edit the given window
+void wxResourceManager::EditWindow(wxWindow *win)
+{
+ wxWindowPropertyInfo *info = CreatePropertyInfoForWindow(win);
+ if (info)
+ {
+ info->SetResource(FindResourceForWindow(win));
+ wxString str("Editing ");
+ str += win->GetClassInfo()->GetClassName();
+ str += ": ";
+ if (win->GetName() != "")
+ str += win->GetName();
+ else
+ str += "properties";
+ info->Edit(NULL, str);
+ }
+}
+
/*
* Resource editor frame
*/
-
-wxResourceEditorFrame::wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, char *title,
- int x, int y, int width, int height, long style, char *name):
- wxFrame(parent, -1, title, wxPoint(x, y), wxSize(width, height), style, name)
+
+IMPLEMENT_CLASS(wxResourceEditorFrame, wxFrame)
+
+BEGIN_EVENT_TABLE(wxResourceEditorFrame, wxFrame)
+ EVT_MENU(wxID_NEW, wxResourceEditorFrame::OnNew)
+ EVT_MENU(RESED_NEW_DIALOG, wxResourceEditorFrame::OnNewDialog)
+ EVT_MENU(wxID_OPEN, wxResourceEditorFrame::OnOpen)
+ EVT_MENU(RESED_CLEAR, wxResourceEditorFrame::OnClear)
+ EVT_MENU(wxID_SAVE, wxResourceEditorFrame::OnSave)
+ EVT_MENU(wxID_SAVEAS, wxResourceEditorFrame::OnSaveAs)
+ EVT_MENU(wxID_EXIT, wxResourceEditorFrame::OnExit)
+ EVT_MENU(wxID_ABOUT, wxResourceEditorFrame::OnAbout)
+ EVT_MENU(RESED_CONTENTS, wxResourceEditorFrame::OnContents)
+ EVT_MENU(RESED_DELETE, wxResourceEditorFrame::OnDeleteSelection)
+ EVT_MENU(RESED_RECREATE, wxResourceEditorFrame::OnRecreateSelection)
+ EVT_MENU(RESED_TEST, wxResourceEditorFrame::OnTest)
+END_EVENT_TABLE()
+
+wxResourceEditorFrame::wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, const wxString& title,
+ const wxPoint& pos, const wxSize& size, long style, const wxString& name):
+ wxFrame(parent, -1, title, pos, size, style, name)
{
manager = resMan;
}
-wxResourceEditorFrame::~wxResourceEditorFrame(void)
+wxResourceEditorFrame::~wxResourceEditorFrame()
{
}
-void wxResourceEditorFrame::OldOnMenuCommand(int cmd)
+void wxResourceEditorFrame::OnNew(wxCommandEvent& event)
{
- switch (cmd)
- {
- case wxID_NEW:
- {
manager->New(FALSE);
- break;
- }
- case RESED_NEW_DIALOG:
- {
- manager->CreateNewDialog();
- break;
- }
- case RESED_NEW_PANEL:
- {
+}
+
+void wxResourceEditorFrame::OnNewDialog(wxCommandEvent& event)
+{
manager->CreateNewPanel();
- break;
- }
- case wxID_OPEN:
- {
+}
+
+void wxResourceEditorFrame::OnOpen(wxCommandEvent& event)
+{
manager->New(TRUE);
- break;
- }
- case RESED_CLEAR:
- {
+}
+
+void wxResourceEditorFrame::OnClear(wxCommandEvent& event)
+{
manager->Clear(TRUE, FALSE);
- break;
- }
- case wxID_SAVE:
- {
+}
+
+void wxResourceEditorFrame::OnSave(wxCommandEvent& event)
+{
manager->Save();
- break;
- }
- case wxID_SAVEAS:
- {
+}
+
+void wxResourceEditorFrame::OnSaveAs(wxCommandEvent& event)
+{
manager->SaveAs();
- break;
- }
- case wxID_EXIT:
- {
+}
+
+void wxResourceEditorFrame::OnExit(wxCommandEvent& event)
+{
manager->Clear(TRUE, FALSE) ;
this->Close();
- break;
- }
- case wxID_ABOUT:
- {
+}
+
+void wxResourceEditorFrame::OnAbout(wxCommandEvent& event)
+{
char buf[300];
sprintf(buf, "wxWindows Dialog Editor %.1f\nAuthor: Julian Smart J.Smart@ed.ac.uk\nJulian Smart (c) 1996", wxDIALOG_EDITOR_VERSION);
- (void)wxMessageBox(buf, "About Dialog Editor", wxOK|wxCENTRE);
- break;
- }
- case RESED_CONTENTS:
- {
+ wxMessageBox(buf, "About Dialog Editor", wxOK|wxCENTRE);
+}
+
+void wxResourceEditorFrame::OnTest(wxCommandEvent& event)
+{
+ // TODO should show the current dialog
+}
+
+void wxResourceEditorFrame::OnContents(wxCommandEvent& event)
+{
wxBeginBusyCursor();
- manager->GetHelpInstance()->LoadFile();
- manager->GetHelpInstance()->DisplayContents();
+ manager->GetHelpController()->LoadFile();
+ manager->GetHelpController()->DisplayContents();
wxEndBusyCursor();
- break;
- }
- case RESED_DELETE:
- {
+}
+
+void wxResourceEditorFrame::OnDeleteSelection(wxCommandEvent& event)
+{
manager->DeleteSelection();
- break;
- }
- case RESED_RECREATE:
- {
+}
+
+void wxResourceEditorFrame::OnRecreateSelection(wxCommandEvent& event)
+{
manager->RecreateSelection();
- break;
- }
- case RESED_TOGGLE_TEST_MODE:
- {
- manager->SetEditMode(!manager->GetEditMode());
- break;
- }
- default:
- break;
- }
}
-bool wxResourceEditorFrame::OnClose(void)
+bool wxResourceEditorFrame::OnClose()
{
if (manager->Modified())
{
-/*
- int ans = wxMessageBox("Save modified resource file?", "Dialog Editor", wxYES_NO | wxCANCEL);
- if (ans == wxCANCEL)
- return FALSE;
- if (ans == wxYES)
- if (!manager->SaveIfModified())
- return FALSE;
-*/
if (!manager->Clear(TRUE, FALSE))
return FALSE;
}
{
int w, h;
GetSize(&w, &h);
- manager->resourceEditorWindowSize.width = w;
- manager->resourceEditorWindowSize.height = h;
+ manager->m_resourceEditorWindowSize.width = w;
+ manager->m_resourceEditorWindowSize.height = h;
int x, y;
GetPosition(&x, &y);
- manager->resourceEditorWindowSize.x = x;
- manager->resourceEditorWindowSize.y = y;
+ manager->m_resourceEditorWindowSize.x = x;
+ manager->m_resourceEditorWindowSize.y = y;
}
manager->SetEditorFrame(NULL);
manager->SetEditorToolBar(NULL);
}
/*
- * Resource editor panel
+ * Resource editor window that contains the dialog/panel being edited
*/
-
-wxResourceEditorPanel::wxResourceEditorPanel(wxWindow *parent, int x, int y, int width, int height,
- long style, char *name):
- wxPanel(parent, -1, wxPoint(x, y), wxSize(width, height), style, name)
+
+BEGIN_EVENT_TABLE(wxResourceEditorScrolledWindow, wxScrolledWindow)
+ EVT_SCROLL(wxResourceEditorScrolledWindow::OnScroll)
+ EVT_PAINT(wxResourceEditorScrolledWindow::OnPaint)
+END_EVENT_TABLE()
+
+wxResourceEditorScrolledWindow::wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos, const wxSize& size,
+ long style):
+ wxScrolledWindow(parent, -1, pos, size, style)
{
+ m_marginX = 10;
+ m_marginY = 40;
+ m_childWindow = NULL;
}
-wxResourceEditorPanel::~wxResourceEditorPanel(void)
+wxResourceEditorScrolledWindow::~wxResourceEditorScrolledWindow()
{
}
-void wxResourceEditorPanel::OnDefaultAction(wxControl *item)
+void wxResourceEditorScrolledWindow::OnScroll(wxScrollEvent& event)
{
- wxResourceEditorFrame *frame = (wxResourceEditorFrame *)GetParent();
- wxResourceManager *manager = frame->manager;
+ wxScrolledWindow::OnScroll(event);
- if (item == manager->GetEditorResourceList())
- {
- manager->EditSelectedResource();
- }
+ int x, y;
+ ViewStart(& x, & y);
+
+ if (m_childWindow)
+ m_childWindow->Move(m_marginX + (- x * 10), m_marginY + (- y * 10));
+}
+
+void wxResourceEditorScrolledWindow::OnPaint(wxPaintEvent& event)
+{
+ wxPaintDC dc(this);
+
+ DrawTitle(dc);
+}
+
+void wxResourceEditorScrolledWindow::DrawTitle(wxDC& dc)
+{
+ if (m_childWindow)
+ {
+ wxItemResource* res = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_childWindow);
+ if (res)
+ {
+ wxString str(res->GetTitle());
+ int x, y;
+ ViewStart(& x, & y);
+
+ wxFont font(10, wxSWISS, wxNORMAL, wxBOLD);
+ dc.SetFont(font);
+ dc.SetBackgroundMode(wxTRANSPARENT);
+ dc.SetTextForeground(wxColour(0, 0, 0));
+
+ long w, h;
+ dc.GetTextExtent(str, & w, & h);
+
+ dc.DrawText(str, m_marginX + (- x * 10), m_marginY + (- y * 10) - h - 5);
+ }
+ }
}
// Popup menu callback
{
case OBJECT_MENU_EDIT:
{
- wxResourceEditWindow(data);
+ wxResourceManager::GetCurrentResourceManager()->EditWindow(data);
break;
}
case OBJECT_MENU_DELETE:
{
- wxResourceManager::currentResourceManager->DeleteResource(data);
+ wxResourceManager::GetCurrentResourceManager()->SaveInfoAndDeleteHandler(data);
+ wxResourceManager::GetCurrentResourceManager()->DeleteResource(data);
+ wxResourceManager::GetCurrentResourceManager()->DeleteWindow(data);
break;
}
default:
}
}
-wxWindowPropertyInfo *wxCreatePropertyInfoForWindow(wxWindow *win)
-{
- wxWindowPropertyInfo *info = NULL;
- if (win->IsKindOf(CLASSINFO(wxScrollBar)))
- {
- info = new wxScrollBarPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxStaticBox)))
- {
- info = new wxGroupBoxPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxCheckBox)))
- {
- info = new wxCheckBoxPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxSlider)))
- {
- info = new wxSliderPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxGauge)))
- {
- info = new wxGaugePropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxListBox)))
- {
- info = new wxListBoxPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxRadioBox)))
- {
- info = new wxRadioBoxPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxChoice)))
- {
- info = new wxChoicePropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxButton)))
- {
- info = new wxButtonPropertyInfo(win);
-/*
- if (((wxButton *)win)->IsBitmap())
- ((wxButtonPropertyInfo *)info)->isBitmapButton = TRUE;
-*/
- }
- else if (win->IsKindOf(CLASSINFO(wxStaticText)))
- {
- info = new wxStaticTextPropertyInfo(win);
-/*
- if (((wxMessage *)win)->IsBitmap())
- ((wxMessagePropertyInfo *)info)->isBitmapMessage = TRUE;
-*/
- }
- else if (win->IsKindOf(CLASSINFO(wxTextCtrl)))
- {
- info = new wxTextPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxDialog)))
- {
- info = new wxDialogPropertyInfo(win);
- }
- else if (win->IsKindOf(CLASSINFO(wxPanel)))
- {
- info = new wxPanelPropertyInfo(win);
- }
- else
- {
- info = new wxWindowPropertyInfo(win);
- }
- return info;
-}
-
-// Popup menu callback
-void wxResourceEditWindow(wxWindow *win)
-{
- wxWindowPropertyInfo *info = wxCreatePropertyInfoForWindow(win);
- if (info)
- {
- info->SetResource(wxResourceManager::currentResourceManager->FindResourceForWindow(win));
- wxString str("Editing ");
- str += win->GetClassInfo()->GetClassName();
- str += ": ";
- if (win->GetName() != "")
- str += win->GetName();
- else
- str += "properties";
- info->Edit(NULL, WXSTRINGCAST str);
- delete info;
- }
-}
-
/*
* Main toolbar
*
*/
-#if defined(__WINDOWS__) && defined(__WIN95__)
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar95)
-#elif defined(__WINDOWS__)
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBarMSW)
-#else
-BEGIN_EVENT_TABLE(EditorToolBar, wxToolBarSimple)
-#endif
+BEGIN_EVENT_TABLE(EditorToolBar, wxToolBar)
EVT_PAINT(EditorToolBar::OnPaint)
END_EVENT_TABLE()
-EditorToolBar::EditorToolBar(wxFrame *frame, int x, int y, int w, int h,
+EditorToolBar::EditorToolBar(wxFrame *frame, const wxPoint& pos, const wxSize& size,
long style, int direction, int RowsOrColumns):
-#if defined(__WINDOWS__) && defined(__WIN95__)
- wxToolBar95(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#elif defined(__WINDOWS__)
- wxToolBarMSW(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#else
- wxToolBarSimple(frame, -1, wxPoint(x, y), wxSize(w, h), style, direction, RowsOrColumns)
-#endif
+ wxToolBar(frame, -1, pos, size, style, direction, RowsOrColumns)
{
}
bool EditorToolBar::OnLeftClick(int toolIndex, bool toggled)
{
- wxResourceManager *manager = wxResourceManager::currentResourceManager;
-
+ wxResourceManager *manager = wxResourceManager::GetCurrentResourceManager();
+
switch (toolIndex)
{
case TOOLBAR_LOAD_FILE:
}
case TOOLBAR_NEW:
{
- manager->New(FALSE);
+ manager->CreateNewPanel();
break;
}
case TOOLBAR_SAVE_FILE:
case TOOLBAR_HELP:
{
wxBeginBusyCursor();
- manager->GetHelpInstance()->LoadFile();
- manager->GetHelpInstance()->DisplayContents();
+ manager->GetHelpController()->LoadFile();
+ manager->GetHelpController()->DisplayContents();
wxEndBusyCursor();
break;
}
void EditorToolBar::OnPaint(wxPaintEvent& event)
{
-#if defined(__WINDOWS__) && defined(__WIN95__)
- wxToolBar95::OnPaint(event);
-#elif defined(__WINDOWS__)
- wxToolBarMSW::OnPaint(event);
-#else
- wxToolBarSimple::OnPaint(event);
-#endif
+ wxToolBar::OnPaint(event);
wxPaintDC dc(this);
int w, h;
dc.DrawLine(0, h-1, w, h-1);
}
-/*
- * Frame for editing a panel in
- */
-
-bool DialogEditorPanelFrame::OnClose(void)
-{
- wxWindow *child = (wxWindow *)GetChildren()->First()->Data();
- wxEvtHandler *handler = child->GetEventHandler();
- return handler->OnClose();
-}
+
#include "wx/string.h"
#include "wx/layout.h"
#include "wx/resource.h"
-#include "wx/tbarsmpl.h"
+#include "wx/toolbar.h"
+#include "wx/imaglist.h"
#include "proplist.h"
-#if defined(__WINDOWS__) && defined(__WIN95__)
-#include "wx/tbar95.h"
-#elif defined(__WINDOWS__)
-#include "wx/tbarmsw.h"
-#endif
-
#define RESED_DELETE 1
-#define RESED_TOGGLE_TEST_MODE 2
#define RESED_RECREATE 3
#define RESED_CLEAR 4
#define RESED_NEW_DIALOG 5
#define RESED_NEW_PANEL 6
+#define RESED_TEST 10
#define RESED_CONTENTS 20
+#define IDC_TREECTRL 100
+#define IDC_LISTCTRL 101
+
+// For control list ('palette')
+#define RESED_POINTER 0
+#define RESED_BUTTON 1
+#define RESED_BMPBUTTON 2
+#define RESED_STATICTEXT 3
+#define RESED_STATICBMP 4
+#define RESED_STATICBOX 5
+#define RESED_TEXTCTRL_SINGLE 6
+#define RESED_TEXTCTRL_MULTIPLE 7
+#define RESED_LISTBOX 8
+#define RESED_CHOICE 9
+#define RESED_COMBOBOX 10
+#define RESED_CHECKBOX 11
+#define RESED_SLIDER 12
+#define RESED_GAUGE 13
+#define RESED_RADIOBOX 14
+#define RESED_RADIOBUTTON 15
+#define RESED_SCROLLBAR 16
+#define RESED_TREECTRL 17
+#define RESED_LISTCTRL 18
+#define RESED_SPINBUTTON 19
+
/*
* Controls loading, saving, user interface of resource editor(s).
*/
class EditorToolPalette;
class EditorToolBar;
class wxWindowPropertyInfo;
+class wxResourceEditorProjectTree;
+class wxResourceEditorControlList;
#ifdef __WINDOWS__
#define wxHelpController wxWinHelpController
class wxResourceTableWithSaving: public wxResourceTable
{
public:
- wxResourceTableWithSaving(void):wxResourceTable()
+ wxResourceTableWithSaving():wxResourceTable()
{
}
virtual bool Save(const wxString& filename);
wxControl *CreateItem(wxPanel *panel, wxItemResource *childResource);
};
+class wxResourceEditorScrolledWindow;
+
class wxResourceManager: public wxObject
{
- protected:
- wxHelpController *helpInstance;
- wxResourceTableWithSaving resourceTable;
- wxFrame *editorFrame;
- wxPanel *editorPanel;
- wxMenu *popupMenu;
- wxListBox *editorResourceList;
- EditorToolPalette *editorPalette;
- EditorToolBar *editorToolBar;
- int nameCounter;
- bool modified;
- bool editMode;
- wxHashTable resourceAssociations;
- wxList selections;
- wxString currentFilename;
-
- public:
-
- // Options to be saved/restored
- wxString optionsResourceFilename; // e.g. dialoged.ini, .dialogrc
- wxRectangle propertyWindowSize;
- wxRectangle resourceEditorWindowSize;
+ friend class wxResourceEditorFrame;
- public:
- static wxResourceManager *currentResourceManager;
+public:
+ wxResourceManager();
+ ~wxResourceManager();
- wxResourceManager(void);
- ~wxResourceManager(void);
+// Operations
- bool Initialize(void);
+ // Initializes the resource manager
+ bool Initialize();
- bool LoadOptions(void);
- bool SaveOptions(void);
+ // Load/save window size etc.
+ bool LoadOptions();
+ bool SaveOptions();
// Show or hide the resource editor frame, which displays a list
// of resources with ability to edit them.
virtual bool ShowResourceEditor(bool show, wxWindow *parent = NULL, const char *title = "wxWindows Dialog Editor");
- virtual bool Save(void);
- virtual bool SaveAs(void);
+ virtual bool Save();
+ virtual bool SaveAs();
virtual bool Save(const wxString& filename);
virtual bool Load(const wxString& filename);
virtual bool Clear(bool deleteWindows = TRUE, bool force = TRUE);
virtual void SetFrameTitle(const wxString& filename);
- virtual bool DisassociateWindows(bool deleteWindows = TRUE);
+ virtual void ClearCurrentDialog();
virtual bool New(bool loadFromFile = TRUE, const wxString& filename = "");
- virtual bool SaveIfModified(void);
+ virtual bool SaveIfModified();
virtual void AlignItems(int flag);
- virtual void CopySize(void);
+ virtual void CopySize();
virtual void ToBackOrFront(bool toBack);
- virtual wxWindow *FindParentOfSelection(void);
+ virtual wxWindow *FindParentOfSelection();
virtual wxFrame *OnCreateEditorFrame(const char *title);
virtual wxMenuBar *OnCreateEditorMenuBar(wxFrame *parent);
- virtual wxPanel *OnCreateEditorPanel(wxFrame *parent);
+ virtual wxResourceEditorScrolledWindow *OnCreateEditorPanel(wxFrame *parent);
virtual wxToolBarBase *OnCreateToolBar(wxFrame *parent);
virtual EditorToolPalette *OnCreatePalette(wxFrame *parent);
-// virtual bool DeletePalette(void);
- virtual bool InitializeTools(void);
- virtual void UpdateResourceList(void);
- virtual void AddItemsRecursively(int level, wxItemResource *resource);
- virtual bool EditSelectedResource(void);
+ // Create a window information object for the give window
+ wxWindowPropertyInfo* CreatePropertyInfoForWindow(wxWindow *win);
+ // Edit the given window
+ void EditWindow(wxWindow *win);
+
+ virtual void UpdateResourceList();
+ virtual void AddItemsRecursively(long parent, wxItemResource *resource);
+ virtual bool EditSelectedResource();
virtual bool Edit(wxItemResource *res);
- virtual bool CreateNewDialog(void);
- virtual bool CreateNewPanel(void);
+ virtual bool CreateNewPanel();
virtual bool CreatePanelItem(wxItemResource *panelResource, wxPanel *panel, char *itemType, int x = 10, int y = 10, bool isBitmap = FALSE);
- virtual bool DeleteSelection(bool deleteWindow = TRUE);
+ virtual bool DeleteSelection();
+
+ // Saves the window info into the resource, and deletes the
+ // handler. Doesn't actually disassociate the window from
+ // the resources. Replaces OnClose.
+ virtual bool SaveInfoAndDeleteHandler(wxWindow* win);
+ // Destroys the window. If this is the 'current' panel, NULLs the
+ // variable.
+ virtual bool DeleteWindow(wxWindow* win);
virtual bool DeleteResource(wxItemResource *res);
- virtual bool DeleteResource(wxWindow *win, bool deleteWindow = TRUE);
+ virtual bool DeleteResource(wxWindow *win);
// Add bitmap resource if there isn't already one with this filename.
virtual char *AddBitmapResource(char *filename);
// fly, you'll need to delete the window and create it again.
virtual wxWindow *RecreateWindowFromResource(wxWindow *win, wxWindowPropertyInfo *info = NULL);
- virtual bool RecreateSelection(void);
+ virtual bool RecreateSelection();
// Need to search through resource table removing this from
// any resource which has this as a parent.
virtual bool EditDialog(wxDialog *dialog, wxWindow *parent);
- inline void SetEditorFrame(wxFrame *fr) { editorFrame = fr; }
- inline void SetEditorToolBar(EditorToolBar *tb) { editorToolBar = tb; }
- inline void SetEditorPalette(EditorToolPalette *pal) { editorPalette = pal; }
- inline wxFrame *GetEditorFrame(void) { return editorFrame; }
- inline wxListBox *GetEditorResourceList(void) { return editorResourceList; }
- inline EditorToolPalette *GetEditorPalette(void) { return editorPalette; }
- inline wxList& GetSelections(void) { return selections; }
-
void AddSelection(wxWindow *win);
void RemoveSelection(wxWindow *win);
-// inline void SetCurrentResource(wxItemResource *item) { currentResource = item; }
-// inline void SetCurrentResourceWindow(wxWindow *win) { currentResourceWindow = win; }
-// inline wxItemResource *GetCurrentResource(void) { return currentResource; }
-// inline wxWindow *GetCurrentResourceWindow(void) { return currentResourceWindow; }
- inline wxMenu *GetPopupMenu(void) { return popupMenu; }
-
- inline wxHelpController *GetHelpInstance(void) { return helpInstance; }
-
virtual void MakeUniqueName(char *prefix, char *buf);
// (Dis)associate resource<->physical window
+ // Doesn't delete any windows.
virtual void AssociateResource(wxItemResource *resource, wxWindow *win);
- virtual bool DisassociateResource(wxItemResource *resource, bool deleteWindow = TRUE);
- virtual bool DisassociateResource(wxWindow *win, bool deleteWindow = TRUE);
+ virtual bool DisassociateResource(wxItemResource *resource);
+ virtual bool DisassociateResource(wxWindow *win);
+ virtual bool DisassociateWindows();
virtual wxItemResource *FindResourceForWindow(wxWindow *win);
virtual wxWindow *FindWindowForResource(wxItemResource *resource);
- virtual bool InstantiateAllResourcesFromWindows(void);
+ virtual bool InstantiateAllResourcesFromWindows();
virtual bool InstantiateResourceFromWindow(wxItemResource *resource, wxWindow *window, bool recurse = FALSE);
- virtual void Modify(bool mod = TRUE) { modified = mod; }
- virtual bool Modified(void) { return modified; }
+// Accessors
+ inline void SetEditorFrame(wxFrame *fr) { m_editorFrame = fr; }
+ inline void SetEditorToolBar(EditorToolBar *tb) { m_editorToolBar = tb; }
+ inline void SetEditorPalette(EditorToolPalette *pal) { m_editorPalette = pal; }
+ inline wxFrame *GetEditorFrame() const { return m_editorFrame; }
+ inline wxResourceEditorProjectTree *GetEditorResourceTree() const { return m_editorResourceTree; }
+ inline wxResourceEditorControlList *GetEditorControlList() const { return m_editorControlList; }
+ inline EditorToolPalette *GetEditorPalette() const { return m_editorPalette; }
+ inline wxList& GetSelections() { return m_selections; }
+ inline wxMenu *GetPopupMenu() const { return m_popupMenu; }
+ inline wxHelpController *GetHelpController() const { return m_helpController; }
- inline bool GetEditMode(void) { return editMode; }
- void SetEditMode(bool flag, bool changeCurrentResource = TRUE);
+ inline void Modify(bool mod = TRUE) { m_modified = mod; }
+ inline bool Modified() const { return m_modified; }
- inline wxResourceTable& GetResourceTable(void) { return resourceTable; }
- inline wxHashTable& GetResourceAssociations(void) { return resourceAssociations; }
-
- inline wxString& GetCurrentFilename(void) { return currentFilename; }
+ inline wxResourceTable& GetResourceTable() { return m_resourceTable; }
+ inline wxHashTable& GetResourceAssociations() { return m_resourceAssociations; }
+
+ inline wxString& GetCurrentFilename() { return m_currentFilename; }
+ static wxResourceManager* GetCurrentResourceManager() { return sm_currentResourceManager; }
+
+ inline wxRect& GetPropertyWindowSize() { return m_propertyWindowSize; }
+ inline wxRect& GetResourceEditorWindowSize() { return m_resourceEditorWindowSize; }
-// void UsePosition(bool usePos, wxItemResource *resource = NULL, int x = 0, int y = 0);
+// Member variables
+ protected:
+ wxHelpController* m_helpController;
+ wxResourceTableWithSaving m_resourceTable;
+ wxFrame* m_editorFrame;
+ wxResourceEditorScrolledWindow* m_editorPanel;
+ wxMenu* m_popupMenu;
+ wxResourceEditorProjectTree* m_editorResourceTree;
+ wxResourceEditorControlList* m_editorControlList;
+ EditorToolPalette* m_editorPalette;
+ EditorToolBar* m_editorToolBar;
+ int m_nameCounter;
+ bool m_modified;
+ wxHashTable m_resourceAssociations;
+ wxList m_selections;
+ wxString m_currentFilename;
+ wxBitmap* m_bitmapImage; // Default for static bitmaps/buttons
+
+ wxImageList m_imageList;
+ long m_rootDialogItem; // Root of dialog hierarchy in tree (unused)
+
+ // Options to be saved/restored
+ wxString m_optionsResourceFilename; // e.g. dialoged.ini, .dialogrc
+ wxRect m_propertyWindowSize;
+ wxRect m_resourceEditorWindowSize;
+ static wxResourceManager* sm_currentResourceManager;
};
+
class wxResourceEditorFrame: public wxFrame
{
public:
+ DECLARE_CLASS(wxResourceEditorFrame)
+
wxResourceManager *manager;
- wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, char *title, int x = -1, int y = -1, int width = 600, int height = 400,
- long style = 0, char *name = "frame");
- ~wxResourceEditorFrame(void);
- void OldOnMenuCommand(int cmd);
- bool OnClose(void);
+ wxResourceEditorFrame(wxResourceManager *resMan, wxFrame *parent, const wxString& title,
+ const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(600, 400),
+ long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame");
+ ~wxResourceEditorFrame();
+
+ bool OnClose();
+
+ void OnNew(wxCommandEvent& event);
+ void OnOpen(wxCommandEvent& event);
+ void OnNewDialog(wxCommandEvent& event);
+ void OnClear(wxCommandEvent& event);
+ void OnSave(wxCommandEvent& event);
+ void OnSaveAs(wxCommandEvent& event);
+ void OnExit(wxCommandEvent& event);
+ void OnAbout(wxCommandEvent& event);
+ void OnContents(wxCommandEvent& event);
+ void OnDeleteSelection(wxCommandEvent& event);
+ void OnRecreateSelection(wxCommandEvent& event);
+ void OnTest(wxCommandEvent& event);
+
+ DECLARE_EVENT_TABLE()
};
-class wxResourceEditorPanel: public wxPanel
+class wxResourceEditorScrolledWindow: public wxScrolledWindow
{
public:
- wxResourceEditorPanel(wxWindow *parent, int x = -1, int y = -1, int width = 600, int height = 400,
- long style = 0, char *name = "panel");
- ~wxResourceEditorPanel(void);
- void OnDefaultAction(wxControl *item);
-};
+ wxResourceEditorScrolledWindow(wxWindow *parent, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+ long style = 0);
+ ~wxResourceEditorScrolledWindow();
+
+ void OnScroll(wxScrollEvent& event);
+ void OnPaint(wxPaintEvent& event);
+
+ void DrawTitle(wxDC& dc);
+
+// Accessors
+ inline int GetMarginX() { return m_marginX; }
+ inline int GetMarginY() { return m_marginY; }
-class DialogEditorPanelFrame: public wxFrame
-{
public:
- DialogEditorPanelFrame(wxFrame *parent, char *title, int x, int y, int w, int h, long style, char *name):
- wxFrame(parent, -1, title, wxPoint(x, y), wxSize(w, h), style, name)
- {
- }
- bool OnClose(void);
-};
+ wxWindow* m_childWindow;
+ private:
+ int m_marginX, m_marginY;
-// Edit menu
-#define OBJECT_EDITOR_NEW_FRAME 220
-#define OBJECT_EDITOR_NEW_DIALOG 221
-#define OBJECT_EDITOR_NEW_PANEL 222
-#define OBJECT_EDITOR_NEW_CANVAS 223
-#define OBJECT_EDITOR_NEW_TEXT_WINDOW 224
-#define OBJECT_EDITOR_NEW_BUTTON 225
-#define OBJECT_EDITOR_NEW_CHECKBOX 226
-#define OBJECT_EDITOR_NEW_MESSAGE 227
-#define OBJECT_EDITOR_NEW_CHOICE 228
-#define OBJECT_EDITOR_NEW_LISTBOX 229
-#define OBJECT_EDITOR_NEW_RADIOBOX 230
-#define OBJECT_EDITOR_NEW_SLIDER 231
-#define OBJECT_EDITOR_NEW_TEXT 232
-#define OBJECT_EDITOR_NEW_MULTITEXT 233
-#define OBJECT_EDITOR_NEW_GAUGE 234
-#define OBJECT_EDITOR_NEW_GROUPBOX 235
-
-#define OBJECT_EDITOR_NEW_ITEM 240
-#define OBJECT_EDITOR_NEW_SUBWINDOW 241
-
-#define OBJECT_EDITOR_EDIT_MENU 250
-#define OBJECT_EDITOR_EDIT_ATTRIBUTES 251
-#define OBJECT_EDITOR_CLOSE_OBJECT 252
-#define OBJECT_EDITOR_DELETE_OBJECT 253
-#define OBJECT_EDITOR_EDIT_TOOLBAR 254
-
-#define OBJECT_EDITOR_TOGGLE_TEST_MODE 255
-
-#define OBJECT_EDITOR_RC_CONVERT 260
-#define OBJECT_EDITOR_RC_CONVERT_MENU 261
-#define OBJECT_EDITOR_RC_CONVERT_DIALOG 262
-
-#define OBJECT_EDITOR_GRID 263
+ DECLARE_EVENT_TABLE()
+};
#define OBJECT_MENU_EDIT 1
#define OBJECT_MENU_DELETE 2
*
*/
-#if defined(__WINDOWS__) && defined(__WIN95__)
-class EditorToolBar: public wxToolBar95
-#elif defined(__WINDOWS__)
-class EditorToolBar: public wxToolBarMSW
-#else
-class EditorToolBar: public wxToolBarSimple
-#endif
+class EditorToolBar: public wxToolBar
{
- public:
- EditorToolBar(wxFrame *frame, int x = 0, int y = 0, int w = -1, int h = -1,
+public:
+ EditorToolBar(wxFrame *frame, const wxPoint& pos = wxPoint(0, 0), const wxSize& size = wxSize(0, 0),
long style = 0, int direction = wxVERTICAL, int RowsOrColumns = 2);
bool OnLeftClick(int toolIndex, bool toggled);
void OnMouseEnter(int toolIndex);
};
// Toolbar ids
-#define TOOLBAR_LOAD_FILE 1
-#define TOOLBAR_SAVE_FILE 2
-#define TOOLBAR_NEW 3
-// #define TOOLBAR_GEN_CLIPS 4
-#define TOOLBAR_TREE 5
-#define TOOLBAR_HELP 6
+#define TOOLBAR_LOAD_FILE 1
+#define TOOLBAR_SAVE_FILE 2
+#define TOOLBAR_NEW 3
+#define TOOLBAR_TREE 5
+#define TOOLBAR_HELP 6
// Formatting tools
-#define TOOLBAR_FORMAT_HORIZ 10
-#define TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN 11
+#define TOOLBAR_FORMAT_HORIZ 10
+#define TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN 11
#define TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN 12
-#define TOOLBAR_FORMAT_VERT 13
-#define TOOLBAR_FORMAT_VERT_TOP_ALIGN 14
-#define TOOLBAR_FORMAT_VERT_BOT_ALIGN 15
+#define TOOLBAR_FORMAT_VERT 13
+#define TOOLBAR_FORMAT_VERT_TOP_ALIGN 14
+#define TOOLBAR_FORMAT_VERT_BOT_ALIGN 15
-#define TOOLBAR_TO_FRONT 16
-#define TOOLBAR_TO_BACK 17
-#define TOOLBAR_COPY_SIZE 18
+#define TOOLBAR_TO_FRONT 16
+#define TOOLBAR_TO_BACK 17
+#define TOOLBAR_COPY_SIZE 18
#endif
{
wxControl *item = wxResourceTable::CreateItem(panel, childResource);
if (item)
- wxResourceManager::currentResourceManager->GetResourceAssociations().Put((long)childResource, item);
+ wxResourceManager::GetCurrentResourceManager()->GetResourceAssociations().Put((long)childResource, item);
return item;
}
stream << " style = '" << styleBuf << "',\\\n";
stream << " title = '" << item->GetTitle() << "',\\\n";
stream << " x = " << item->GetX() << ", y = " << item->GetY();
- stream << ", width = " << item->GetWidth() << ", height = " << item->GetHeight() << ",\\\n";
- stream << " modal = " << item->GetValue1();
+ stream << ", width = " << item->GetWidth() << ", height = " << item->GetHeight();
+// stream << " modal = " << item->GetValue1();
- if (item->GetStyle() & wxUSER_COLOURS)
+ if (1) // item->GetStyle() & wxNO_3D)
{
if (item->GetBackgroundColour())
{
stream << ",\\\n " << "background_colour = '" << buf << "'";
}
+#if 0
if (item->GetLabelColour())
{
char buf[7];
stream << ",\\\n " << "button_colour = '" << buf << "'";
}
+#endif
+
}
- if (item->GetFont())
+ if (item->GetFont() && item->GetFont()->Ok())
{
stream << ",\\\n font = ";
OutputFont(stream, item->GetFont());
}
-/*
- if (item->GetButtonFont())
- {
- stream << ",\\\n button_font = ";
- OutputFont(stream, item->GetButtonFont());
- }
-*/
-
+
if (item->GetChildren().Number() > 0)
stream << ",\\\n";
else
}
stream << ").\";\n\n";
}
- else if (itemType == "wxButton")
+ else if (itemType == "wxButton" || itemType == "wxBitmapButton")
{
GenerateButtonStyleString(item->GetStyle(), styleBuf);
- stream << "wxButton, " << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
+ stream << itemType << ", " << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
stream << SafeWord(item->GetName()) << ", " << item->GetX() << ", " << item->GetY() << ", ";
stream << item->GetWidth() << ", " << item->GetHeight();
if (item->GetValue4())
OutputFont(stream, item->GetFont());
}
}
- else if (itemType == "wxMessage")
+ else if (itemType == "wxStaticText" || itemType == "wxStaticBitmap")
{
GenerateMessageStyleString(item->GetStyle(), styleBuf);
- stream << "wxMessage, " << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
+ stream << itemType << ", " << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
stream << SafeWord(item->GetName()) << ", " << item->GetX() << ", " << item->GetY() << ", ";
stream << item->GetWidth() << ", " << item->GetHeight();
if (item->GetValue4())
OutputFont(stream, item->GetFont());
}
}
- else if (itemType == "wxGroupBox")
+ else if (itemType == "wxStaticBox")
{
GenerateGroupBoxStyleString(item->GetStyle(), styleBuf);
stream << "wxGroupBox, " << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
OutputFont(stream, item->GetFont());
}
}
- else if (itemType == "wxText" || itemType == "wxMultiText")
+ else if (itemType == "wxText" || itemType == "wxMultiText" || itemType == "wxTextCtrl")
{
GenerateTextStyleString(item->GetStyle(), styleBuf);
- stream << ((itemType == "wxText") ? "wxText, " : "wxMultiText, ");
+ stream << "wxTextCtrl, ";
stream << SafeWord(item->GetTitle()) << ", '" << styleBuf << "', ";
stream << SafeWord(item->GetName()) << ", " << item->GetX() << ", " << item->GetY() << ", ";
stream << item->GetWidth() << ", " << item->GetHeight();
void wxResourceTableWithSaving::GenerateWindowStyleString(long windowStyle, char *buf)
{
- GenerateStyle(buf, windowStyle, wxUSER_COLOURS, "wxUSER_COLOURS");
+ GenerateStyle(buf, windowStyle, wxNO_3D, "wxNO_3D");
GenerateStyle(buf, windowStyle, wxVSCROLL, "wxVSCROLL");
GenerateStyle(buf, windowStyle, wxHSCROLL, "wxHSCROLL");
GenerateStyle(buf, windowStyle, wxBORDER, "wxBORDER");
GenerateStyle(buf, windowStyle, wxTE_PROCESS_ENTER, "wxTE_PROCESS_ENTER");
GenerateStyle(buf, windowStyle, wxTE_READONLY, "wxTE_READONLY");
GenerateStyle(buf, windowStyle, wxTE_PASSWORD, "wxTE_PASSWORD");
+ GenerateStyle(buf, windowStyle, wxTE_MULTILINE, "wxTE_MULTILINE");
if (strlen(buf) == 0)
strcat(buf, "0");
GetManagedWindow()->GetSize(& w, & h);
GetManagedWindow()->GetPosition(& x, & y);
- wxResourceManager::currentResourceManager->propertyWindowSize.width = w;
- wxResourceManager::currentResourceManager->propertyWindowSize.height = h;
- wxResourceManager::currentResourceManager->propertyWindowSize.x = x;
- wxResourceManager::currentResourceManager->propertyWindowSize.y = y;
+ wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width = w;
+ wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height = h;
+ wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x = x;
+ wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y = y;
return wxPropertyListView::OnClose();
}
+wxWindow *wxPropertyInfo::sm_propertyWindow;
+
/*
- * wxPropertyInfo
+ * wxDialogEditorPropertyListDialog
*/
-wxWindow *wxPropertyInfo::sm_propertyWindow;
+wxDialogEditorPropertyListDialog::wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
+ const wxPoint& pos, const wxSize& size,
+ long style, const wxString& name):
+ wxPropertyListDialog(v, parent, title, pos, size, style, name)
+{
+ m_propSheet = NULL;
+ m_propInfo = NULL;
+}
+
+wxDialogEditorPropertyListDialog::~wxDialogEditorPropertyListDialog()
+{
+ delete m_propSheet;
+ delete m_propInfo;
+ wxPropertyInfo::sm_propertyWindow = NULL;
+}
+
+/*
+ * wxPropertyInfo
+ */
// Edit the information represented by this object, whatever that
// might be.
-bool wxPropertyInfo::Edit(wxWindow *parent, char *title)
+bool wxPropertyInfo::Edit(wxWindow *parent, const wxString& title)
{
- int width = wxResourceManager::currentResourceManager->propertyWindowSize.width;
- int height = wxResourceManager::currentResourceManager->propertyWindowSize.height;
- int x = wxResourceManager::currentResourceManager->propertyWindowSize.x;
- int y = wxResourceManager::currentResourceManager->propertyWindowSize.y;
-
+ if (sm_propertyWindow)
+ return FALSE;
+
+ int width = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().width;
+ int height = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().height;
+ int x = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().x;
+ int y = wxResourceManager::GetCurrentResourceManager()->GetPropertyWindowSize().y;
+
wxPropertySheet *propSheet = new wxPropertySheet;
wxStringList propNames;
// Reset 'modified' flags for all property values
propSheet->SetAllModified(FALSE);
- if (!title)
- title = "Properties";
wxResourcePropertyListView *view = new wxResourcePropertyListView(this, NULL,
#ifdef __XVIEW__
wxPROP_BUTTON_OK | wxPROP_BUTTON_CANCEL |
#endif
wxPROP_BUTTON_CHECK_CROSS|wxPROP_DYNAMIC_VALUE_FIELD|wxPROP_PULLDOWN|wxPROP_SHOWVALUES);
- wxPropertyListDialog *propDialog = new wxPropertyListDialog(view, NULL, title, wxPoint(x, y), wxSize(width, height), wxDIALOG_MODAL|wxDEFAULT_DIALOG_STYLE);
+ wxDialogEditorPropertyListDialog *propDialog = new wxDialogEditorPropertyListDialog(view,
+ wxResourceManager::GetCurrentResourceManager()->GetEditorFrame(), title, wxPoint(x, y),
+ wxSize(width, height), wxDEFAULT_DIALOG_STYLE);
sm_propertyWindow = propDialog;
-
- wxPropertyValidatorRegistry theValidatorRegistry;
- theValidatorRegistry.RegisterValidator((wxString)"real", new wxRealListValidator);
- theValidatorRegistry.RegisterValidator((wxString)"string", new wxStringListValidator);
- theValidatorRegistry.RegisterValidator((wxString)"integer", new wxIntegerListValidator);
- theValidatorRegistry.RegisterValidator((wxString)"bool", new wxBoolListValidator);
- theValidatorRegistry.RegisterValidator((wxString)"filename", new wxFilenameListValidator);
- theValidatorRegistry.RegisterValidator((wxString)"stringlist", new wxListOfStringsListValidator);
+
+ propDialog->m_registry.RegisterValidator((wxString)"real", new wxRealListValidator);
+ propDialog->m_registry.RegisterValidator((wxString)"string", new wxStringListValidator);
+ propDialog->m_registry.RegisterValidator((wxString)"integer", new wxIntegerListValidator);
+ propDialog->m_registry.RegisterValidator((wxString)"bool", new wxBoolListValidator);
+ propDialog->m_registry.RegisterValidator((wxString)"filename", new wxFilenameListValidator);
+ propDialog->m_registry.RegisterValidator((wxString)"stringlist", new wxListOfStringsListValidator);
+
+ propDialog->m_propInfo = this;
+ propDialog->m_propSheet = propSheet;
// view->propertyWindow = propDialog;
- view->AddRegistry(&theValidatorRegistry);
+ view->AddRegistry(&(propDialog->m_registry));
view->ShowView(propSheet, propDialog);
- int ret = propDialog->ShowModal();
- sm_propertyWindow = NULL;
- delete propSheet;
-
- if ( ret == wxID_CANCEL )
- return FALSE;
- else
- return TRUE;
+ propDialog->Show(TRUE);
+ return TRUE;
}
/*
else if (name == "name")
{
// Remove old name from resource table, if it's there.
- wxItemResource *oldResource = (wxItemResource *)wxResourceManager::currentResourceManager->GetResourceTable().Delete(propertyWindow->GetName());
+ wxItemResource *oldResource = (wxItemResource *)wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Delete(propertyWindow->GetName());
if (oldResource)
{
// It's a top-level resource
propertyWindow->SetName(property->GetValue().StringValue());
oldResource->SetName(property->GetValue().StringValue());
- wxResourceManager::currentResourceManager->GetResourceTable().Put(propertyWindow->GetName(), oldResource);
+ wxResourceManager::GetCurrentResourceManager()->GetResourceTable().Put(propertyWindow->GetName(), oldResource);
}
else
{
propertyResource->SetName(property->GetValue().StringValue());
}
// Refresh the resource manager list, because the name changed.
- wxResourceManager::currentResourceManager->UpdateResourceList();
+ wxResourceManager::GetCurrentResourceManager()->UpdateResourceList();
return TRUE;
}
else if (name == "title")
if (width != newWidth)
{
propertyWindow->SetSize(newWidth, height);
+/*
if (propertyWindow->IsKindOf(CLASSINFO(wxPanel)) && !propertyWindow->IsKindOf(CLASSINFO(wxDialog)))
{
propertyWindow->GetParent()->SetClientSize(newWidth, height);
}
+*/
}
return TRUE;
}
if (height != newHeight)
{
propertyWindow->SetSize(width, newHeight);
+/*
if (propertyWindow->IsKindOf(CLASSINFO(wxPanel)) && !propertyWindow->IsKindOf(CLASSINFO(wxDialog)))
{
propertyWindow->GetParent()->SetClientSize(width, newHeight);
}
+*/
}
return TRUE;
}
/*
- * Panel items
+ * Controls
*/
wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
wxControl *item = (wxControl *)propertyWindow;
wxString str(item->GetLabel());
resource->SetTitle(WXSTRINGCAST str);
- if (item->GetFont())
+ if (item->GetFont() && item->GetFont()->Ok())
resource->SetFont(wxTheFontList->FindOrCreateFont(item->GetFont()->GetPointSize(),
item->GetFont()->GetFamily(), item->GetFont()->GetStyle(), item->GetFont()->GetWeight(),
item->GetFont()->GetUnderlined(), item->GetFont()->GetFaceName()));
wxProperty *wxButtonPropertyInfo::GetProperty(wxString& name)
{
wxButton *button = (wxButton *)propertyWindow;
+ return wxItemPropertyInfo::GetProperty(name);
+}
+
+bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
+{
+ wxButton *button = (wxButton *)propertyWindow;
+ return wxItemPropertyInfo::SetProperty(name, property);
+}
+
+void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
+{
+ names.Add("label");
+ wxItemPropertyInfo::GetPropertyNames(names);
+}
+
+bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
+{
+ return wxItemPropertyInfo::InstantiateResource(resource);
+}
+
/*
- if (name == "label" && isBitmapButton)
+ * wxBitmapButton
+ */
+
+wxProperty *wxBitmapButtonPropertyInfo::GetProperty(wxString& name)
+{
+ wxBitmapButton *button = (wxBitmapButton *)propertyWindow;
+ if (name == "label")
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(button);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
wxString str("none.bmp");
if (resource)
{
- char *filename = wxResourceManager::currentResourceManager->FindBitmapFilenameForResource(resource);
+ char *filename = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
if (filename)
str = filename;
}
return new wxProperty("label", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
}
else
-*/
- return wxItemPropertyInfo::GetProperty(name);
+ return wxButtonPropertyInfo::GetProperty(name);
}
-bool wxButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
+bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
- wxButton *button = (wxButton *)propertyWindow;
-/*
- if (name == "label" && isBitmapButton)
+ wxBitmapButton *button = (wxBitmapButton *)propertyWindow;
+ if (name == "label")
{
char *s = property->GetValue().StringValue();
if (s && wxFileExists(s))
}
else
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(button);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(button);
if (resource)
{
wxString oldResource(resource->GetValue4());
- char *resName = wxResourceManager::currentResourceManager->AddBitmapResource(s);
+ char *resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
resource->SetValue4(resName);
if (!oldResource.IsNull())
- wxResourceManager::currentResourceManager->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
+ wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
}
button->SetLabel(bitmap);
return FALSE;
}
else
-*/
- return wxItemPropertyInfo::SetProperty(name, property);
+ return wxButtonPropertyInfo::SetProperty(name, property);
}
-void wxButtonPropertyInfo::GetPropertyNames(wxStringList& names)
+void wxBitmapButtonPropertyInfo::GetPropertyNames(wxStringList& names)
{
- names.Add("label");
- wxItemPropertyInfo::GetPropertyNames(names);
+// names.Add("label");
+ wxButtonPropertyInfo::GetPropertyNames(names);
}
-bool wxButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
+bool wxBitmapButtonPropertyInfo::InstantiateResource(wxItemResource *resource)
{
return wxItemPropertyInfo::InstantiateResource(resource);
}
/*
- * Message
+ * wxStaticText
*/
wxProperty *wxStaticTextPropertyInfo::GetProperty(wxString& name)
{
wxStaticText *message = (wxStaticText *)propertyWindow;
+ return wxItemPropertyInfo::GetProperty(name);
+}
+
+bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
+{
+ wxStaticText *message = (wxStaticText *)propertyWindow;
+ return wxItemPropertyInfo::SetProperty(name, property);
+}
+
+void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
+{
+ names.Add("label");
+ wxItemPropertyInfo::GetPropertyNames(names);
+}
+
+bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
+{
+ return wxItemPropertyInfo::InstantiateResource(resource);
+}
+
/*
- if (name == "label" && isBitmapMessage)
+ * wxStaticBitmap
+ */
+
+wxProperty *wxStaticBitmapPropertyInfo::GetProperty(wxString& name)
+{
+ wxStaticBitmap *message = (wxStaticBitmap *)propertyWindow;
+ if (name == "label")
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(message);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
wxString str("none.bmp");
if (resource)
{
- char *filename = wxResourceManager::currentResourceManager->FindBitmapFilenameForResource(resource);
+ char *filename = wxResourceManager::GetCurrentResourceManager()->FindBitmapFilenameForResource(resource);
if (filename)
str = filename;
}
return new wxProperty("label", str.GetData(), "string", new wxFilenameListValidator("Select a bitmap file", "*.bmp"));
}
else
-*/
return wxItemPropertyInfo::GetProperty(name);
}
-bool wxStaticTextPropertyInfo::SetProperty(wxString& name, wxProperty *property)
+bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
- wxStaticText *message = (wxStaticText *)propertyWindow;
-/*
- if (name == "label" && isBitmapMessage)
+ wxStaticBitmap *message = (wxStaticBitmap *)propertyWindow;
+ if (name == "label")
{
char *s = property->GetValue().StringValue();
if (s && wxFileExists(s))
}
else
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(message);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(message);
if (resource)
{
wxString oldResource(resource->GetValue4());
- char *resName = wxResourceManager::currentResourceManager->AddBitmapResource(s);
+ char *resName = wxResourceManager::GetCurrentResourceManager()->AddBitmapResource(s);
resource->SetValue4(resName);
if (!oldResource.IsNull())
- wxResourceManager::currentResourceManager->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
+ wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(WXSTRINGCAST oldResource);
}
- message->SetLabel(bitmap);
+ message->SetBitmap(bitmap);
delete[] s;
return TRUE;
}
return FALSE;
}
else
-*/
return wxItemPropertyInfo::SetProperty(name, property);
}
-void wxStaticTextPropertyInfo::GetPropertyNames(wxStringList& names)
+void wxStaticBitmapPropertyInfo::GetPropertyNames(wxStringList& names)
{
names.Add("label");
wxItemPropertyInfo::GetPropertyNames(names);
}
-bool wxStaticTextPropertyInfo::InstantiateResource(wxItemResource *resource)
+bool wxStaticBitmapPropertyInfo::InstantiateResource(wxItemResource *resource)
{
return wxItemPropertyInfo::InstantiateResource(resource);
}
if ((flag & wxTE_PASSWORD) == wxTE_PASSWORD)
flag -= wxTE_PASSWORD;
}
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(text);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
resource->SetStyle(flag);
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(text, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
return TRUE;
}
else if (name == "readonly")
if ((flag & wxTE_READONLY) == wxTE_READONLY)
flag -= wxTE_READONLY;
}
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(text);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(text);
resource->SetStyle(flag);
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(text, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(text, this);
return TRUE;
}
else
else if (name == "multiple")
{
char *pos = NULL;
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(listBox);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
if (!resource)
return NULL;
mult = wxLB_EXTENDED;
else
mult = wxLB_SINGLE;
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(listBox);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(listBox);
if (resource)
resource->SetValue1(mult);
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(listBox, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(listBox, this);
return TRUE;
}
else
if (name == "numberRowsOrCols")
{
radioBox->SetNumberOfRowsOrCols((int)property->GetValue().IntegerValue());
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(radioBox, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
return TRUE;
}
else if (name == "orientation")
}
radioBox->SetWindowStyleFlag(windowStyle);
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(radioBox, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
return TRUE;
}
else if (name == "values")
// Set property into *resource*, not wxRadioBox, and then recreate
// the wxRadioBox. This is because we can't dynamically set the strings
// of a wxRadioBox.
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(propertyWindow);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(propertyWindow);
if (!resource)
return FALSE;
stringList->Add(s);
expr = expr->GetNext();
}
- wxResourceManager::currentResourceManager->RecreateWindowFromResource(radioBox, this);
+ wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(radioBox, this);
return TRUE;
}
return wxItemPropertyInfo::SetProperty(name, property);
int w, h;
slider->GetSize(&w, &h);
- slider = (wxSlider *)wxResourceManager::currentResourceManager->RecreateWindowFromResource(slider, this);
+ slider = (wxSlider *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(slider, this);
slider->SetSize(-1, -1, h, w);
return TRUE;
int w, h;
scrollBar->GetSize(&w, &h);
- scrollBar = (wxScrollBar *)wxResourceManager::currentResourceManager->RecreateWindowFromResource(scrollBar, this);
+ scrollBar = (wxScrollBar *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(scrollBar, this);
scrollBar->SetSize(-1, -1, h, w);
return TRUE;
else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
name == "buttonFontUnderlined")
return GetFontProperty(name, buttonFont);
- else if (name == "userColours")
+ else if (name == "no3D")
{
bool userColours;
- if (panelWindow->GetWindowStyleFlag() & wxUSER_COLOURS)
+ if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
userColours = TRUE;
else
userColours = FALSE;
return new wxProperty(name, buf, "string", new wxColourListValidator);
}
+ else if (name == "title")
+ {
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+ if (resource)
+ return new wxProperty(name, resource->GetTitle(), "string");
+ else
+ return new wxProperty(name, "Could not get title", "string");
+ }
else
return wxWindowPropertyInfo::GetProperty(name);
}
panelWindow->SetButtonFont(newFont);
return TRUE;
}
- else if (name == "userColours")
+ else if (name == "no3D")
{
bool userColours = property->GetValue().BoolValue();
long flag = panelWindow->GetWindowStyleFlag();
if (userColours)
{
- if ((panelWindow->GetWindowStyleFlag() & wxUSER_COLOURS) != wxUSER_COLOURS)
- panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() | wxUSER_COLOURS);
+ if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) != wxNO_3D)
+ panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() | wxNO_3D);
}
else
{
- if ((panelWindow->GetWindowStyleFlag() & wxUSER_COLOURS) == wxUSER_COLOURS)
- panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() - wxUSER_COLOURS);
+ if ((panelWindow->GetWindowStyleFlag() & wxNO_3D) == wxNO_3D)
+ panelWindow->SetWindowStyleFlag(panelWindow->GetWindowStyleFlag() - wxNO_3D);
}
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(panelWindow);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
resource->SetStyle(panelWindow->GetWindowStyleFlag());
- panelWindow = (wxPanel *)wxResourceManager::currentResourceManager->RecreateWindowFromResource(panelWindow, this);
-// panelWindow->SetUserEditMode(wxResourceManager::currentResourceManager->GetEditMode());
-#ifdef __WINDOWS__
- // This window should not be enabled by being recreated: we're in a modal dialog (property editor)
- ::EnableWindow((HWND) panelWindow->GetHWND(), FALSE);
- ::BringWindowToTop((HWND) sm_propertyWindow->GetHWND());
-#endif
+ panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
return TRUE;
}
else if (name == "backgroundColour")
wxColour col(r,g,b);
panelWindow->SetBackgroundColour(col);
- panelWindow = (wxPanel *)wxResourceManager::currentResourceManager->RecreateWindowFromResource(panelWindow, this);
-// panelWindow->SetUserEditMode(wxResourceManager::currentResourceManager->GetEditMode());
-#ifdef __WINDOWS__
- // This window should not be enabled by being recreated: we're in a modal dialog (property editor)
- ::EnableWindow((HWND) panelWindow->GetHWND(), FALSE);
- ::BringWindowToTop((HWND) sm_propertyWindow->GetHWND());
-#endif
+ panelWindow = (wxPanel *)wxResourceManager::GetCurrentResourceManager()->RecreateWindowFromResource(panelWindow, this);
return TRUE;
}
+ else if (name == "title")
+ {
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(panelWindow);
+ if (resource)
+ {
+ resource->SetTitle(property->GetValue().StringValue());
+ return TRUE;
+ }
+ else
+ return FALSE;
+ }
else
return wxWindowPropertyInfo::SetProperty(name, property);
}
{
wxWindowPropertyInfo::GetPropertyNames(names);
-// names.Add("orientation");
- names.Add("userColours");
+ names.Add("title");
+ names.Add("no3D");
names.Add("backgroundColour");
}
return wxWindowPropertyInfo::InstantiateResource(resource);
}
+#if 0
/*
* Dialog boxes
*/
wxDialog *dialogWindow = (wxDialog *)propertyWindow;
if (name == "modal")
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(dialogWindow);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
if (!resource)
return NULL;
if (name == "modal")
{
- wxItemResource *resource = wxResourceManager::currentResourceManager->FindResourceForWindow(dialogWindow);
+ wxItemResource *resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(dialogWindow);
if (!resource)
return FALSE;
return wxPanelPropertyInfo::InstantiateResource(resource);
}
+#endif
/*
* Utilities
class wxPropertyInfo;
+class wxDialogEditorPropertyListDialog: public wxPropertyListDialog
+{
+ friend class wxPropertyInfo;
+public:
+ wxDialogEditorPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
+ const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+ long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "dialogBox");
+ ~wxDialogEditorPropertyListDialog();
+
+private:
+ wxPropertySheet* m_propSheet;
+ wxPropertyValidatorRegistry m_registry;
+ wxPropertyInfo* m_propInfo;
+};
+
// A kind of property list view that intercepts OnPropertyChanged
// feedback.
class wxResourcePropertyListView: public wxPropertyListView
// them with separate classes.
class wxPropertyInfo: public wxObject
{
+ friend class wxDialogEditorPropertyListDialog;
protected:
static wxWindow *sm_propertyWindow;
wxPropertyInfo(void)
virtual wxProperty *GetProperty(wxString& propName) = 0;
virtual bool SetProperty(wxString& propName, wxProperty *property) = 0;
virtual void GetPropertyNames(wxStringList& names) = 0;
- virtual bool Edit(wxWindow *parent, char *title);
+ virtual bool Edit(wxWindow *parent, const wxString& title);
};
// For all windows
{
protected:
public:
- bool isBitmapButton;
- wxButtonPropertyInfo(wxWindow *win, wxItemResource *res = NULL, bool bmButton = FALSE):
- wxItemPropertyInfo(win, res) { isBitmapButton = bmButton; }
+ wxButtonPropertyInfo(wxWindow *win, wxItemResource *res = NULL):
+ wxItemPropertyInfo(win, res) { }
~wxButtonPropertyInfo(void) {}
wxProperty *GetProperty(wxString& name);
bool SetProperty(wxString& name, wxProperty *property);
void GetPropertyNames(wxStringList& names);
bool InstantiateResource(wxItemResource *resource);
+};
- inline bool IsBitmapButton(void) { return isBitmapButton; }
+// For bitmap buttons
+class wxBitmapButtonPropertyInfo: public wxButtonPropertyInfo
+{
+ protected:
+ public:
+ wxBitmapButtonPropertyInfo(wxWindow *win, wxItemResource *res = NULL):
+ wxButtonPropertyInfo(win, res) { }
+ ~wxBitmapButtonPropertyInfo(void) {}
+ wxProperty *GetProperty(wxString& name);
+ bool SetProperty(wxString& name, wxProperty *property);
+ void GetPropertyNames(wxStringList& names);
+ bool InstantiateResource(wxItemResource *resource);
};
-// For messages
+// For static text controls
class wxStaticTextPropertyInfo: public wxItemPropertyInfo
{
protected:
public:
- bool isBitmapMessage;
- wxStaticTextPropertyInfo(wxWindow *win, wxItemResource *res = NULL, bool bmMessage = FALSE):
- wxItemPropertyInfo(win, res) { isBitmapMessage = bmMessage; }
+ wxStaticTextPropertyInfo(wxWindow *win, wxItemResource *res = NULL):
+ wxItemPropertyInfo(win, res) { }
~wxStaticTextPropertyInfo(void) {}
wxProperty *GetProperty(wxString& name);
bool SetProperty(wxString& name, wxProperty *property);
void GetPropertyNames(wxStringList& names);
bool InstantiateResource(wxItemResource *resource);
+};
- inline bool IsBitmapMessage(void) { return isBitmapMessage; }
+// For static bitmap controls
+class wxStaticBitmapPropertyInfo: public wxItemPropertyInfo
+{
+ protected:
+ public:
+ wxStaticBitmapPropertyInfo(wxWindow *win, wxItemResource *res = NULL):
+ wxItemPropertyInfo(win, res) { }
+ ~wxStaticBitmapPropertyInfo(void) {}
+ wxProperty *GetProperty(wxString& name);
+ bool SetProperty(wxString& name, wxProperty *property);
+ void GetPropertyNames(wxStringList& names);
+ bool InstantiateResource(wxItemResource *resource);
};
// For text/multitext items
bool InstantiateResource(wxItemResource *resource);
};
-// For dialogs
-class wxDialogPropertyInfo: public wxPanelPropertyInfo
-{
- protected:
- public:
- wxDialogPropertyInfo(wxWindow *win, wxItemResource *res = NULL):
- wxPanelPropertyInfo(win, res) {}
- ~wxDialogPropertyInfo(void) {}
- wxProperty *GetProperty(wxString& name);
- bool SetProperty(wxString& name, wxProperty *property);
- void GetPropertyNames(wxStringList& names);
- bool InstantiateResource(wxItemResource *resource);
-};
-
int wxStringToFontWeight(wxString& val);
int wxStringToFontStyle(wxString& val);
int wxStringToFontFamily(wxString& val);
projects / wxWidgets.git / commitdiff
