void tst_storage::tst_alldayUtc()
{
// test event saved with UTC time
auto event = KCalCore::Event::Ptr(new KCalCore::Event);
QDate startDate(2013, 12, 1);
event->setDtStart(KDateTime(startDate, QTime(), KDateTime::UTC));
event->setAllDay(true);
event->setSummary("test event utc");
QCOMPARE(event->allDay(), true);
m_calendar->addEvent(event, NotebookId);
m_storage->save();
QString uid = event->uid();
reloadDb();
auto fetchedEvent = m_calendar->event(uid);
QVERIFY(fetchedEvent.data());
QVERIFY(fetchedEvent->dtStart().isUtc());
KDateTime localStart = fetchedEvent->dtStart().toLocalZone();
QVERIFY(localStart.time() == QTime(2, 0));
KDateTime localEnd = fetchedEvent->dtEnd().toLocalZone();
QVERIFY(localEnd.time() == QTime(2, 0));
QCOMPARE(localEnd.date(), localStart.date().addDays(1));
}
void COXTreeCal::Init(HTREEITEM hItem,int iItem,int iSubItem)
{
m_iItem= iItem;
m_iSubItem = iSubItem;
COXTreeCtrl *pTreeCtrl = (COXTreeCtrl*) GetParent();
CStringArray& sa = pTreeCtrl->GetItemTextEx(hItem,iSubItem);
m_wndEdit.SetWindowText(pTreeCtrl->GetItemText(hItem,iSubItem));
if(sa.GetSize() == 0)
return;
COleDateTime dtStart(0,0,0,0,0,0);
COleDateTime dtEnd(9999,12,31,0,0,0);
if(sa.GetSize() > 0)
{
CString sFirstDate = sa[0];
dtStart.ParseDateTime(sFirstDate);
}
if(sa.GetSize() > 1)
{
CString sEndDate = sa[1];
dtEnd.ParseDateTime(sEndDate);
}
SetDateRange(dtStart,dtEnd);
}
// Create the left walls, start must point to a segment with a wall on the left and a leading
// non wall segment.
// FIXME: Does not work for a closed ring "by design".
void buildWalls(tTrackSeg *start, int side) {
if (start == NULL) {
return;
}
tTrackSeg *current = start;
bool close = false;
// Going down the wall.
do {
tTrackSeg* s = current->side[side];
tTrackSeg* p = current->prev->side[side];
tTrackSeg* n = current->next->side[side];
// Current segment is a wall?
if (s != NULL && s->style == TR_WALL && s->side[side] != NULL) {
float h = s->height;
t3Dd svl = s->vertex[TR_SL];
t3Dd svr = s->vertex[TR_SR];
t3Dd evl = s->vertex[TR_EL];
t3Dd evr = s->vertex[TR_ER];
static float weps = 0.01f;
// Close the start with a ploygon?
if (p == NULL || p->style != TR_WALL ||
(fabs(p->vertex[TR_EL].x - svl.x) > weps) ||
(fabs(p->vertex[TR_ER].x - svr.x) > weps) ||
(fabs(h - p->height) > weps) ||
fixedid == 0)
{
// Enough space in array?
if (fixedid >= sizeof(fixedobjects)/sizeof(fixedobjects[0])) {
GfError("fixedobjects full in %s, line %d\n", __FILE__, __LINE__);
return;
}
if (close == true) {
dtEndComplexShape();
GfError("Shape not closed %s, line %d\n", __FILE__, __LINE__);
}
// Start new shape.
fixedobjects[fixedid] = dtNewComplexShape();
fixedid++;
close = true;
dtBegin(DT_POLYGON);
dtVertex(svl.x, svl.y, svl.z);
dtVertex(svr.x, svr.y, svr.z);
dtVertex(svr.x, svr.y, svr.z + h);
dtVertex(svl.x, svl.y, svl.z + h);
dtEnd();
}
// Build sides, left, top, right. Depending on how we want to use it we
// can remove top perhaps.
// TODO: do we want the top poly?
if (close == true) {
// Left.
dtBegin(DT_POLYGON);
dtVertex(svl.x, svl.y, svl.z);
dtVertex(svl.x, svl.y, svl.z + h);
dtVertex(evl.x, evl.y, evl.z + h);
dtVertex(evl.x, evl.y, evl.z);
dtEnd();
/*
// Top.
dtBegin(DT_POLYGON);
dtVertex(svl.x, svl.y, svl.z + h);
dtVertex(svr.x, svr.y, svr.z + h);
dtVertex(evr.x, evr.y, evr.z + h);
dtVertex(evl.x, evl.y, evl.z + h);
dtEnd();*/
// Right.
dtBegin(DT_POLYGON);
dtVertex(svr.x, svr.y, svr.z + h);
dtVertex(svr.x, svr.y, svr.z);
dtVertex(evr.x, evr.y, evr.z);
dtVertex(evr.x, evr.y, evr.z + h);
dtEnd();
} else {
GfError("Shape not open %s, line %d\n", __FILE__, __LINE__);
}
// Close the end with a ploygon?
if (n == NULL || n->style != TR_WALL ||
(fabs(n->vertex[TR_SL].x - evl.x) > weps) ||
(fabs(n->vertex[TR_SR].x - evr.x) > weps) ||
(fabs(h - n->height) > weps))
{
if (close == true) {
dtBegin(DT_POLYGON);
dtVertex(svl.x, svl.y, svl.z);
dtVertex(svr.x, svr.y, svr.z);
dtVertex(svr.x, svr.y, svr.z + h);
dtVertex(svl.x, svl.y, svl.z + h);
dtEnd();
dtEndComplexShape();
close = false;
} else {
GfError("Shape not open %s, line %d\n", __FILE__, __LINE__);
}
}
}
current = current->next;
} while (current != start);
}
int main(int argc, char** argv)
{
object1.id = 1;
object2.id = 2;
/*vec3 boxMax1 = vec3(2, 2, 2);
vec3 boxMax2 = vec3(1, 1, 1);
boxobj1 = BoundingBox(-boxMax1, boxMax1);
boxobj2 = BoundingBox(-boxMax2, boxMax2);
*/
boxobj1 = BoundingBox(vec3(-0.9438, -0.4669, -0.61679), vec3(0.607788, 1.06996, 0.587146));
boxobj2 = BoundingBox(vec3(1.056195, -0.46690, -0.6167920), vec3(2.6077880000000002, 1.0699599999999998, 0.58714600000000006));
/*
DtShapeRef shape1 = dtBox(boxMax1.x * 2, boxMax1.y * 2, boxMax1.z * 2);
DtShapeRef shape2 = dtBox(boxMax2.x * 2, boxMax2.y * 2, boxMax2.z * 2);
*/
vector<Point> solid_points0;
vector<CP_Vector3D> points0 = boxobj1.GetAABBVertices();
for(int i = 0; i < points0.size(); i++)
solid_points0.push_back(Point(points0[i].x, points0[i].y, points0[i].z));
vector<DtIndex> solid_indices0;
auto indices = boxobj1.GetAABBIndices();
for(auto it = indices.begin(); it != indices.end(); it++)
solid_indices0.push_back(*it);
DtShapeRef shape1 = dtNewComplexShape();
dtVertexBase(&solid_points0[0]);
for(int i = 0; i < solid_indices0.size()/3; i++)
{
dtBegin(DT_SIMPLEX);
dtVertexIndex(solid_indices0[i*3+0]);
dtVertexIndex(solid_indices0[i*3+1]);
dtVertexIndex(solid_indices0[i*3+2]);
dtEnd();
}
//dtVertexIndices(DT_POLYHEDRON, solid_indices0.size(), &solid_indices0[0]);
dtEndComplexShape();
vector<Point> solid_points1;
vector<CP_Vector3D> points1 = boxobj2.GetAABBVertices();
for(int i = 0; i < points1.size(); i++)
solid_points1.push_back(Point(points1[i].x, points1[i].y, points1[i].z));
auto indices1 = boxobj2.GetAABBIndices();
vector<DtIndex> solid_indices1(indices1.begin(), indices1.end());
DtShapeRef shape2 = dtNewComplexShape();
dtVertexBase(&solid_points1[0]);
for(int i = 0; i < solid_indices1.size()/3; i++)
{
dtBegin(DT_SIMPLEX);
dtVertexIndex(solid_indices1[i*3+0]);
dtVertexIndex(solid_indices1[i*3+1]);
dtVertexIndex(solid_indices1[i*3+2]);
dtEnd();
}
//dtVertexIndices(DT_POLYHEDRON, solid_indices1.size(), &solid_indices1[0]);
dtEndComplexShape();
dtCreateObject(&object1, shape1);
dtCreateObject(&object2, shape2);
dtDisableCaching();
dtSetDefaultResponse(collide1, DT_SIMPLE_RESPONSE, stdout);
if(NO_DISPLAY) return 0;
draw(argc, argv);
return 0;
}
void mmBudgetingPanel::initVirtualListControl()
{
budget_.clear();
budgetTotals_.clear();
budgetPeriod_.clear();
budgetAmt_.clear();
categoryStats_.clear();
double estIncome = 0.0;
double estExpenses = 0.0;
double actIncome = 0.0;
double actExpenses = 0.0;
mmReportBudget budgetDetails;
bool evaluateTransfer = false;
if (mmIniOptions::instance().budgetIncludeTransfers_)
{
evaluateTransfer = true;
}
currentView_ = Model_Infotable::instance().GetStringInfo("BUDGET_FILTER", VIEW_ALL);
const wxString budgetYearStr = Model_Budgetyear::instance().Get(budgetYearID_);
long year = 0;
budgetYearStr.ToLong(&year);
wxDateTime dtBegin(1, wxDateTime::Jan, year);
wxDateTime dtEnd(31, wxDateTime::Dec, year);
monthlyBudget_ = (budgetYearStr.length() > 5);
if (monthlyBudget_)
{
budgetDetails.SetBudgetMonth(budgetYearStr, dtBegin, dtEnd);
}
else
{
int day = -1, month = -1;
budgetDetails.AdjustYearValues(day, month, dtBegin);
budgetDetails.AdjustDateForEndFinancialYear(dtEnd);
}
mmSpecifiedRange date_range(dtBegin, dtEnd);
//Get statistics
Model_Budget::instance().getBudgetEntry(budgetYearID_, budgetPeriod_, budgetAmt_);
Model_Category::instance().getCategoryStats(categoryStats_
, &date_range, mmIniOptions::instance().ignoreFutureTransactions_
, false, true, (evaluateTransfer ? &budgetAmt_ : 0));
const Model_Subcategory::Data_Set& allSubcategories = Model_Subcategory::instance().all(Model_Subcategory::COL_SUBCATEGNAME);
for (const auto& category : Model_Category::instance().all(Model_Category::COL_CATEGNAME))
{
double estimated = getEstimate(category.CATEGID, -1);
if (estimated < 0)
estExpenses += estimated;
else
estIncome += estimated;
double actual = 0;
if (currentView_ != VIEW_PLANNED || estimated != 0)
{
actual = categoryStats_[category.CATEGID][-1][0];
if (actual < 0)
actExpenses += actual;
else
actIncome += actual;
}
/***************************************************************************
Create a TOTALS entry for the category.
***************************************************************************/
double catTotalsEstimated = estimated;
double catTotalsActual = actual;
if (DisplayEntryAllowed(category.CATEGID, -1))
budget_.push_back(std::make_pair(category.CATEGID, -1));
for (const auto& subcategory : allSubcategories)
{
if (subcategory.CATEGID != category.CATEGID) continue;
estimated = getEstimate(category.CATEGID, subcategory.SUBCATEGID);
if (estimated < 0)
estExpenses += estimated;
else
estIncome += estimated;
actual = 0;
if (currentView_ != VIEW_PLANNED || estimated != 0)
{
actual = categoryStats_[category.CATEGID][subcategory.SUBCATEGID][0];
if (actual < 0)
actExpenses += actual;
else
actIncome += actual;
}
/***************************************************************************
Update the TOTALS entry for the subcategory.
***************************************************************************/
catTotalsEstimated += estimated;
catTotalsActual += actual;
if (DisplayEntryAllowed(category.CATEGID, subcategory.SUBCATEGID))
budget_.push_back(std::make_pair(category.CATEGID, subcategory.SUBCATEGID));
}
budgetTotals_[category.CATEGID].first = catTotalsEstimated;
budgetTotals_[category.CATEGID].second = catTotalsActual;
if ((!mmIniOptions::instance().budgetSetupWithoutSummaries_ || currentView_ == VIEW_SUMM)
&& DisplayEntryAllowed(-1, category.CATEGID))
{
budget_.push_back(std::make_pair(-1, category.CATEGID));
int transCatTotalIndex = (int)budget_.size() - 1;
listCtrlBudget_->RefreshItem(transCatTotalIndex);
}
}
listCtrlBudget_->SetItemCount((int)budget_.size());
wxString est_amount, act_amount, diff_amount;
est_amount = Model_Currency::toCurrency(estIncome);
act_amount = Model_Currency::toCurrency(actIncome);
diff_amount = Model_Currency::toCurrency(estIncome - actIncome);
income_estimated_->SetLabelText(est_amount);
income_actual_->SetLabelText(act_amount);
income_diff_->SetLabelText(diff_amount);
if (estExpenses < 0.0) estExpenses = -estExpenses;
if (actExpenses < 0.0) actExpenses = -actExpenses;
est_amount = Model_Currency::toCurrency(estExpenses);
act_amount = Model_Currency::toCurrency(actExpenses);
diff_amount = Model_Currency::toCurrency(estExpenses - actExpenses);
expenses_estimated_->SetLabelText(est_amount);
expenses_actual_->SetLabelText(act_amount);
expenses_diff_->SetLabelText(diff_amount);
UpdateBudgetHeading();
}