/*
void MathPrintout::RecalculateSize()
{
wxConfig *config = (wxConfig *)wxConfig::Get();
int fontsize = 12;
config->Read(wxT("fontSize"), &fontsize);
GroupCell* tmp = m_tree;
double scale = GetPPIScale();
wxDC *dc = GetDC();
CellParser parser(*dc, scale);
int marginX, marginY;
GetPageMargins(&marginX, &marginY);
marginX += SCALE_PX(MC_BASE_INDENT, scale);
parser.SetIndent(marginX);
while (tmp != NULL)
{
tmp->RecalculateSize(parser, fontsize, false);
tmp = tmp->m_next;
}
}
*/
void MathPrintout::Recalculate()
{
wxConfig *config = (wxConfig *)wxConfig::Get();
int fontsize = 12;
config->Read(wxT("fontSize"), &fontsize);
int mfontsize = fontsize;
config->Read(wxT("mathfontsize"), &mfontsize);
GroupCell* tmp = (GroupCell *)m_tree;
double scale = GetPPIScale();
wxDC *dc = GetDC();
CellParser parser(*dc, scale);
int marginX, marginY;
GetPageMargins(&marginX, &marginY);
int pageWidth, pageHeight;
GetPageSizePixels(&pageWidth, &pageHeight);
parser.SetClientWidth(pageWidth - marginX - marginY
- SCALE_PX(MC_BASE_INDENT, scale));
marginX += SCALE_PX(MC_BASE_INDENT, scale);
parser.SetIndent(marginX);
while (tmp != NULL)
{
tmp->Recalculate(parser, fontsize, mfontsize);
tmp = (GroupCell *)tmp->m_next;
}
}
void Bitmap::Layout()
{
if (m_tree->GetType() != MC_TYPE_GROUP)
{
RecalculateWidths();
BreakUpCells();
BreakLines();
RecalculateSize();
}
else {
int fontsize = 12;
wxConfig::Get()->Read(wxT("fontSize"), &fontsize);
int mfontsize = fontsize;
wxConfig::Get()->Read(wxT("mathfontsize"), &mfontsize);
GroupCell* tmp = (GroupCell *)m_tree;
wxMemoryDC dc;
dc.SelectObject(m_bmp);
CellParser parser(dc);
parser.SetClientWidth(BM_FULL_WIDTH);
while (tmp != NULL)
{
tmp->Recalculate(parser, fontsize, mfontsize);
tmp = (GroupCell *)tmp->m_next;
}
}
int width, height;
GetMaxPoint(&width, &height);
m_bmp.Create(width, height);
Draw();
}
GroupCell *GroupCell::Fold() {
if (!IsFoldable() || m_hiddenTree) // already folded?? shouldn't happen
return NULL;
if (m_next == NULL)
return NULL;
int nextgct = dynamic_cast<GroupCell*>(m_next)->GetGroupType(); // groupType of the next cell
if ((m_groupType == nextgct) || IsLesserGCType(nextgct))
return NULL; // if the next gc shouldn't be folded, exit
// now there is at least one cell to fold (at least m_next)
GroupCell *end = dynamic_cast<GroupCell*>(m_next);
GroupCell *start = end; // first to fold
while (end) {
GroupCell *tmp = dynamic_cast<GroupCell*>(end->m_next);
if (tmp == NULL)
break;
if ((m_groupType == tmp->GetGroupType()) || IsLesserGCType(tmp->GetGroupType()))
break; // the next one of the end is not suitable for folding, break
end = tmp;
}
// cell(s) to fold are between start and end (including these two)
MathCell *next = end->m_next;
m_next = m_nextToDraw = next; // may be NULL, it's ok
if (next)
next->m_previous = next->m_previousToDraw = this;
start->m_previous = start->m_previousToDraw = NULL;
end->m_next = end->m_nextToDraw = NULL;
m_hiddenTree = start; // save the torn out tree into m_hiddenTree
m_hiddenTree->SetHiddenTreeParent(this);
return this;
}
TableViewCell* LayerGroupList::tableCellAtIndex(TableView *table, ssize_t idx)
{
GroupCell* cell = dynamic_cast<GroupCell*>(table->dequeueCell());
if(!cell)
{
cell = GroupCell::create();
}
auto data = groups_.at(idx);
cell->update_property(data);
return cell;
}
MathCell* GroupCell::Copy()
{
GroupCell* tmp = new GroupCell(m_groupType);
tmp->Hide(m_hide);
CopyData(this, tmp);
if (m_input)
tmp->SetInput(m_input->CopyList());
if (m_output != NULL)
tmp->SetOutput(m_output->CopyList());
return tmp;
}
MathCell* GroupCell::Copy(bool all)
{
GroupCell* tmp = new GroupCell(m_groupType);
tmp->Hide(m_hide);
CopyData(this, tmp);
if (m_input)
tmp->SetInput(m_input->Copy(true));
if (m_output != NULL)
tmp->SetOutput(m_output->Copy(true));
if (all && m_next != NULL)
tmp->AppendCell(m_next->Copy(all));
return tmp;
}
void GridClustering::insertToGroup(const BoundingBox & box, const unsigned & idx)
{
const Vector3F center = box.center();
GroupCell * c = insertChild((const float *)¢er);
if(!c) {
std::cout<<"\n error cast to GroupCell";
return;
}
c->insert(idx);
c->m_box.expandBy(box);
}
bool Emfout::Layout()
{
if(m_recalculationDc == NULL)
return false;
(*m_configuration)->SetContext(*m_recalculationDc);
if (m_tree->GetType() != MC_TYPE_GROUP)
{
RecalculateWidths();
BreakUpCells();
BreakLines();
RecalculateHeight();
}
else
{
GroupCell *tmp = dynamic_cast<GroupCell *>(m_tree);
while (tmp != NULL)
{
tmp->Recalculate();
tmp = dynamic_cast<GroupCell *>(tmp->m_next);
}
}
if(!m_recalculationDc->IsOk())
{
return false;
}
GetMaxPoint(&m_width, &m_height);
if(m_dc != NULL)
{
m_dc->Close();
wxDELETE(m_dc);
}
// Let's switch to a DC of the right size for our object.
m_dc = new wxEnhMetaFileDC(m_filename, m_width, m_height);
if(m_dc != NULL)
{
(*m_configuration)->SetContext(*m_dc);
Draw();
// Closing the DC seems to trigger the actual output of the file.
m_dc->Close();
wxDELETE(m_dc);
m_dc = NULL;
}
return true;
}
void LayerGroupList::update_unread_message_count()
{
Vector<TableViewCell*> cellsUsed = tableview_->get_cellsUsed();
if (cellsUsed.size() > 0)
{
for (auto cell_iter : cellsUsed)
{
GroupCell * groupCellIter = dynamic_cast<GroupCell*>(cell_iter);
if (groupCellIter)
{
groupCellIter->update_unread_message_count();
}
}
}
}
// unfolds recursivly its contents
// if (all) then also calls it on it's m_next
GroupCell *GroupCell::UnfoldAll() {
GroupCell *result = NULL;
GroupCell *tmp = this;
while (tmp != NULL)
{
if (tmp->IsFoldable() && tmp->m_hiddenTree)
{
tmp->Unfold();
result = tmp;
}
if (tmp-> m_hiddenTree)
m_hiddenTree->UnfoldAll();
tmp = dynamic_cast<GroupCell*>(tmp->m_next);
}
return result;
}
void MathPrintout::BreakPages()
{
if (m_tree == NULL)
return ;
int pageWidth, pageHeight;
int marginX, marginY;
int headerHeight = GetHeaderHeight();
double scale = GetPPIScale();
GetPageMargins(&marginX, &marginY);
GetPageSizePixels(&pageWidth, &pageHeight);
int currentHeight = marginY;
int skip = SCALE_PX(MC_GROUP_SKIP, scale);;
GroupCell* tmp = (GroupCell *)m_tree;
m_pages.push_back(tmp);
m_numberOfPages = 1;
while (tmp != NULL)
{
tmp->BreakPage(false);
if (currentHeight + tmp->GetMaxHeight() + skip >= pageHeight - marginY ||
tmp->GetGroupType() == GC_TYPE_PAGEBREAK)
{
if (tmp->GetGroupType() != GC_TYPE_PAGEBREAK)
currentHeight = marginY + tmp->GetMaxHeight() + headerHeight;
tmp->BreakPage(true);
m_pages.push_back(tmp);
m_numberOfPages++;
}
else
currentHeight += tmp->GetMaxHeight() + skip;
tmp = (GroupCell *)tmp->m_next;
}
}
bool MathPrintout::OnPrintPage(int num)
{
double screenScaleX, screenScaleY;
double ppiScale;
GroupCell* tmp;
wxDC* dc = GetDC();
int marginX, marginY;
GetPageMargins(&marginX, &marginY);
ppiScale = GetPPIScale();
GetScreenScale(&screenScaleX, &screenScaleY);
marginX += SCALE_PX(MC_BASE_INDENT, ppiScale);
dc->SetUserScale(screenScaleX, screenScaleY);
// Go to current page
tmp = (GroupCell *)m_pages[num - 1];
// Print page
if (tmp != NULL)
{
if (tmp->GetGroupType() == GC_TYPE_PAGEBREAK)
tmp = (GroupCell *)tmp->m_next;
if (tmp == NULL)
return true;
wxPoint point;
point.x = marginX;
point.y = marginY + tmp->GetMaxCenter() + GetHeaderHeight();
wxConfigBase* config = wxConfig::Get();
int fontsize = 12;
int drop = tmp->GetMaxDrop();
config->Read(wxT("fontsize"), &fontsize);
PrintHeader(num, dc, ppiScale);
CellParser parser(*dc, ppiScale);
parser.SetIndent(marginX);
while (tmp != NULL && tmp->GetGroupType() != GC_TYPE_PAGEBREAK)
{
tmp->Draw(parser, point, fontsize, false);
if (tmp->m_next != NULL) {
point.x = marginX;
point.y += drop + tmp->m_next->GetMaxCenter();
point.y += SCALE_PX(MC_GROUP_SKIP, ppiScale);
drop = tmp->m_next->GetMaxDrop();
}
tmp = (GroupCell *)tmp->m_next;
if (tmp == NULL || tmp->BreakPageHere())
break;
}
return true;
}
return false;
}
// ParseCellTag
// This function is responsible for creating
// a tree of groupcells when loading XML document.
// Any changes in GroupCell structure or methods
// has to be reflected here in order to ensure proper
// loading of WXMX files.
MathCell* MathParser::ParseCellTag(wxXmlNode* node)
{
GroupCell *group = NULL;
// read hide status
#if wxCHECK_VERSION(2,9,0)
bool hide = (node->GetAttribute(wxT("hide"), wxT("false")) == wxT("true")) ? true : false;
#else
bool hide = (node->GetPropVal(wxT("hide"), wxT("false")) == wxT("true")) ? true : false;
#endif
// read (group)cell type
#if wxCHECK_VERSION(2,9,0)
wxString type = node->GetAttribute(wxT("type"), wxT("text"));
#else
wxString type = node->GetPropVal(wxT("type"), wxT("text"));
#endif
if (type == wxT("code")) {
group = new GroupCell(GC_TYPE_CODE);
wxXmlNode *children = node->GetChildren();
while (children) {
if (children->GetName() == wxT("input")) {
MathCell *editor = ParseTag(children->GetChildren());
group->SetEditableContent(editor->GetValue());
delete editor;
}
if (children->GetName() == wxT("output"))
group->AppendOutput(ParseTag(children->GetChildren()));
children = children->GetNext();
}
}
else if (type == wxT("image")) {
group = new GroupCell(GC_TYPE_IMAGE);
wxXmlNode *children = node->GetChildren();
while (children) {
if (children->GetName() == wxT("editor")) {
MathCell *ed = ParseEditorTag(children);
group->SetEditableContent(ed->GetValue());
delete ed;
}
else
group->AppendOutput(ParseTag(children));
children = children->GetNext();
}
}
else if (type == wxT("pagebreak")) {
group = new GroupCell(GC_TYPE_PAGEBREAK);
}
else if (type == wxT("text")) {
group = new GroupCell(GC_TYPE_TEXT);
MathCell *editor = ParseTag(node->GetChildren());
group->SetEditableContent(editor->GetValue());
delete editor;
}
else {
// text types
if (type == wxT("title"))
group = new GroupCell(GC_TYPE_TITLE);
else if (type == wxT("section"))
group = new GroupCell(GC_TYPE_SECTION);
else if (type == wxT("subsection"))
group = new GroupCell(GC_TYPE_SUBSECTION);
else
return NULL;
wxXmlNode *children = node->GetChildren();
while (children) {
if (children->GetName() == wxT("editor")) {
MathCell *ed = ParseEditorTag(children);
group->SetEditableContent(ed->GetValue());
delete ed;
}
else if (children->GetName() == wxT("fold")) { // we have folded groupcells
wxXmlNode *xmlcells = children->GetChildren();
MathCell *tree = NULL;
MathCell *last = NULL;
if (xmlcells) {
last = tree = ParseTag(xmlcells, false); // first cell
while (xmlcells->GetNext()) {
xmlcells = xmlcells->GetNext();
MathCell *cell = ParseTag(xmlcells, false);
last->m_next = last->m_nextToDraw = cell;
last->m_next->m_previous = last->m_next->m_previousToDraw = last;
last = last->m_next;
}
if (tree)
group->HideTree((GroupCell *)tree);
}
}
children = children->GetNext();
}
}
group->SetParent(group, false);
group->Hide(hide);
return group;
}
bool MathPrintout::OnPrintPage(int num)
{
double screenScaleX, screenScaleY;
double ppiScale;
GroupCell* tmp;
wxDC* dc = GetDC();
int marginX, marginY;
GetPageMargins(&marginX, &marginY);
ppiScale = GetPPIScale();
GetScreenScale(&screenScaleX, &screenScaleY);
marginX += SCALE_PX(MC_BASE_INDENT, ppiScale);
dc->SetUserScale(screenScaleX, screenScaleY);
// Go to current page
tmp = (GroupCell *)m_pages[num - 1];
// Print page
if (tmp != NULL)
{
if (tmp->GetGroupType() == GC_TYPE_PAGEBREAK)
tmp = (GroupCell *)tmp->m_next;
if (tmp == NULL)
return true;
wxPoint point;
point.x = marginX;
point.y = marginY + tmp->GetMaxCenter() + GetHeaderHeight();
wxConfigBase* config = wxConfig::Get();
int fontsize = 12;
int drop = tmp->GetMaxDrop();
config->Read(wxT("fontsize"), &fontsize);
PrintHeader(num, dc, ppiScale);
CellParser parser(*dc, ppiScale);
parser.SetIndent(marginX);
// Inform the output routines that we are printing
parser.SetPrinter(true);
// Make sure that during print nothing is outside the crop rectangle
MathCell::ClipToDrawRegion(true);
while (tmp != NULL && tmp->GetGroupType() != GC_TYPE_PAGEBREAK)
{
// The following line seems to misteriously fix the "subsequent text
// cells aren't printed" problem on linux.
// No Idea why, though.
dc->SetPen(wxPen(wxT("light grey"), 1, wxPENSTYLE_SOLID));
tmp->Draw(point, fontsize);
if (tmp->m_next != NULL) {
point.x = marginX;
point.y += drop + tmp->m_next->GetMaxCenter();
point.y += SCALE_PX(MC_GROUP_SKIP, ppiScale);
drop = tmp->m_next->GetMaxDrop();
}
tmp = (GroupCell *)tmp->m_next;
if (tmp == NULL || tmp->BreakPageHere())
break;
}
MathCell::ClipToDrawRegion(false);
return true;
}
MathCell::ClipToDrawRegion(false);
return false;
}
// ToXML
// writes a groupcell in the form of
// <cell type="code" hide="true">
// --contents--
// </cell>
wxString GroupCell::ToXML(bool all)
{
wxString str;
str = wxT("\n<cell"); // start opening tag
// write "type" according to m_groupType
switch (m_groupType) {
case GC_TYPE_CODE:
str += wxT(" type=\"code\"");
break;
case GC_TYPE_IMAGE:
str += wxT(" type=\"image\"");
break;
case GC_TYPE_TEXT:
str += wxT(" type=\"text\"");
break;
case GC_TYPE_TITLE:
str += wxT(" type=\"title\"");
break;
case GC_TYPE_SECTION:
str += wxT(" type=\"section\"");
break;
case GC_TYPE_SUBSECTION:
str += wxT(" type=\"subsection\"");
break;
case GC_TYPE_PAGEBREAK:
{
str += wxT(" type=\"pagebreak\"/>");
return str + MathCell::ToXML(all);
}
break;
default:
str += wxT(" type=\"unknown\"");
break;
}
// write hidden status
if (m_hide)
str += wxT(" hide=\"true\"");
str += wxT(">\n");
MathCell *input = GetInput();
MathCell *output = GetLabel();
// write contents
switch (m_groupType) {
case GC_TYPE_CODE:
if (input != NULL) {
str += wxT("<input>\n");
str += input->ToXML(false);
str += wxT("</input>");
}
if (output != NULL) {
str += wxT("\n<output>\n");
str += wxT("<mth>") + output->ToXML(true) + wxT("</mth>");
str += wxT("\n</output>");
}
break;
case GC_TYPE_IMAGE:
if (input != NULL)
str += input->ToXML(false);
if (output != NULL)
str += output->ToXML(true);
break;
case GC_TYPE_TEXT:
if (input)
str += input->ToXML(false);
break;
case GC_TYPE_TITLE:
case GC_TYPE_SECTION:
case GC_TYPE_SUBSECTION:
if (input)
str += input->ToXML(false);
if (m_hiddenTree) {
str += wxT("<fold>");
GroupCell *tmp = m_hiddenTree;
while (tmp) {
str += tmp->ToXML(false);
tmp = dynamic_cast<GroupCell*>(tmp->m_next);
}
str += wxT("</fold>");
}
break;
default:
if (output != NULL)
str += output->ToXML(false);
break;
}
str += wxT("\n</cell>\n");
return str + MathCell::ToXML(all);
}
