Ejemplo n.º 1
0
void product_stats::refresh()
{

    int type = Choice1->GetSelection(); //0 - by revenue, 1 - by quantity


    mysqlpp::Query query = conn->query();
    wxDateTime start_date = DatePickerCtrl1->GetValue();
    wxDateTime end_date = DatePickerCtrl2->GetValue();
    wxDateTime mysql_end_date = end_date;
    mysql_end_date.Add(wxTimeSpan::Day());

    switch(type)
    {
    case 0:
        query << "SELECT `name` , SUM( `qty` ) AS `qty`, SUM(`qty`*`price`) AS `money_net`,SUM(`qty`*`price`*`tax`) AS `money_tax`\
FROM `orders_dishes` WHERE `order_id` = ANY (SELECT `id` FROM `orders` \
WHERE `time` > '"<< wx2std(start_date.FormatISODate(),wxConvUI) <<"' AND `time` < '"<< wx2std(mysql_end_date.FormatISODate(),wxConvUI) <<"')\
 GROUP BY `name` ORDER BY `money_net` DESC LIMIT " << wx2std(Choice2->GetStringSelection(),wxConvUI);
        break;
    case 1:
        query << "SELECT `name` , SUM( `qty` ) AS `qty`, SUM(`qty`*`price`) AS `money_net`,SUM(`qty`*`price`*`tax`) AS `money_tax`\
FROM `orders_dishes` WHERE `order_id` = ANY (SELECT `id` FROM `orders` \
WHERE `time` > '"<< wx2std(start_date.FormatISODate(),wxConvUI) <<"' AND `time` < '"<< wx2std(mysql_end_date.FormatISODate(),wxConvUI) <<"')\
 GROUP BY `name` ORDER BY `qty` DESC LIMIT " << wx2std(Choice2->GetStringSelection(),wxConvUI);
        break;
    }
    mysqlpp::StoreQueryResult res = query.store();
    if (res)
    {
        wxString info;
        info << _("Name of the product       |   Qty   |   Net   |   Taxes   |   Gross\n\n");

        wxString infoVerse;
        mysqlpp::Row row;
        mysqlpp::StoreQueryResult::size_type i;
        for (i = 0; i < res.num_rows(); ++i)
        {
            row = res[i];
            infoVerse.Clear();
            std::string name = std::string(row["name"]);
            int qty = int(row["qty"]);
            double money_net = round_2(double(row["money_net"]));
            double money_tax = round_2(double(row["money_tax"]));


            infoVerse << addSpaces(std2wx(name,wxConvUI),31);
            wxString temp;
            temp << qty;
            infoVerse << addSpaces(temp,8);
            infoVerse << addSpaces(addZero(money_net),11);
            infoVerse << addSpaces(addZero(money_tax),12);
            infoVerse << addZero(money_net + money_tax) << _T("\n");
            info << infoVerse;

        }
        TextCtrl1->ChangeValue(info);
    }

}
Ejemplo n.º 2
0
void
modes_pre(void)
{
	if(vle_mode_is(CMDLINE_MODE))
	{
		touchwin(status_bar);
		wrefresh(status_bar);
		return;
	}
	else if(ANY(vle_mode_is, SORT_MODE, CHANGE_MODE, ATTR_MODE))
	{
		return;
	}
	else if(vle_mode_is(VIEW_MODE))
	{
		view_pre();
		return;
	}
	else if(is_in_menu_like_mode())
	{
		menu_pre();
		return;
	}

	if(!curr_stats.save_msg)
	{
		clean_status_bar();
		wrefresh(status_bar);
	}
}
Ejemplo n.º 3
0
/*
 * Dump DDP statistics structure.
 */
void
ddp_stats(u_long off __unused, const char *name, int af1 __unused)
{
	struct ddpstat ddpstat;

	if (off == 0)
		return;
	kread(off, (char *)&ddpstat, sizeof (ddpstat));
	printf("%s:\n", name);
	ANY(ddpstat.ddps_short, "packet", " with short headers ");
	ANY(ddpstat.ddps_long, "packet", " with long headers ");
	ANY(ddpstat.ddps_nosum, "packet", " with no checksum ");
	ANY(ddpstat.ddps_tooshort, "packet", " too short ");
	ANY(ddpstat.ddps_badsum, "packet", " with bad checksum ");
	ANY(ddpstat.ddps_toosmall, "packet", " with not enough data ");
	ANY(ddpstat.ddps_forward, "packet", " forwarded ");
	ANY(ddpstat.ddps_encap, "packet", " encapsulated ");
	ANY(ddpstat.ddps_cantforward, "packet", " rcvd for unreachable dest ");
	ANY(ddpstat.ddps_nosockspace, "packet", " dropped due to no socket space ");
}
Ejemplo n.º 4
0
int
perform_operation(int op, struct object *o)
{
#ifdef TESLA
	/* A very simple TESLA assertion. */
	TESLA_WITHIN(example_syscall,
		previously(security_check(ANY(ptr), o, op) == 0));

	/* An even simpler assertion! */
	TESLA_WITHIN(example_syscall, previously(call(security_check)));

	/* More simple assertions. */
	TESLA_WITHIN(example_syscall, previously(call(hold(o))));
	TESLA_WITHIN(example_syscall, previously(returnfrom(hold(o))));
	TESLA_WITHIN(example_syscall, eventually(call(release(o))));

	/* A simple assertion about struct manipulation. */
	TESLA_WITHIN(example_syscall, previously(o->refcount += 1));

	/* An example of using high-level TESLA macros. */
	TESLA_WITHIN(example_syscall,
		previously(security_check(ANY(ptr), o, op) == 0)
		||
		eventually(log_audit_record(o, op) == 0)
	);

	/* An example of using the lower-level TESLA interface. */
	TESLA_GLOBAL(call(example_syscall), returnfrom(example_syscall),
		TSEQUENCE(
			get_object(ANY(int), ANY(ptr)) == 0,
			security_check(ANY(ptr), o, op) == 0,
			some_helper(op) == 0 || call(never_actually_called),
			optional(call(void_helper(o))),
			TESLA_ASSERTION_SITE,
			returnfrom(release(o))
		)
	);
#endif

	return 0;
}
Ejemplo n.º 5
0
/*ARGSUSED*/
void
ipxerr_stats(u_long off, const char *name, int af __unused, int proto __unused)
{
	struct ipx_errstat ipx_errstat;
	int j;
	int histoprint = 1;
	int z;

	if (off == 0)
		return;
	kread(off, (char *)&ipx_errstat, sizeof (ipx_errstat));
	printf("IPX error statistics:\n");
	ANY(ipx_errstat.ipx_es_error, "call", " to ipx_error");
	ANY(ipx_errstat.ipx_es_oldshort, "error",
		" ignored due to insufficient addressing");
	ANY(ipx_errstat.ipx_es_oldipx_err, "error request",
		" in response to error packets");
	ANY(ipx_errstat.ipx_es_tooshort, "error packet",
		" received incomplete");
	ANY(ipx_errstat.ipx_es_badcode, "error packet",
		" received of unknown type");
	for(j = 0; j < IPX_ERR_MAX; j ++) {
		z = ipx_errstat.ipx_es_outhist[j];
		if (z && histoprint) {
			printf("Output Error Histogram:\n");
			histoprint = 0;
		}
		ipx_erputil(z, ipx_errstat.ipx_es_codes[j]);
	}
	histoprint = 1;
	for(j = 0; j < IPX_ERR_MAX; j ++) {
		z = ipx_errstat.ipx_es_inhist[j];
		if (z && histoprint) {
			printf("Input Error Histogram:\n");
			histoprint = 0;
		}
		ipx_erputil(z, ipx_errstat.ipx_es_codes[j]);
	}
}
Ejemplo n.º 6
0
static void
ipx_erputil(int z, int c)
{
	int j;
	char codebuf[30];
	char *name, *where;

	for(j = 0;; j ++) {
		if ((name = ipx_errnames[j].name) == 0)
			break;
		if (ipx_errnames[j].code == c)
			break;
	}
	if (name == 0)  {
		if (c > 01000)
			where = "in transit";
		else
			where = "at destination";
		sprintf(codebuf, "Unknown IPX error code 0%o", c);
		name = codebuf;
	} else
		where =  ipx_errnames[j].where;
	ANY(z, name, where);
}
Ejemplo n.º 7
0
void
modes_post(void)
{
	if(ANY(vle_mode_is, CMDLINE_MODE, SORT_MODE, CHANGE_MODE, ATTR_MODE))
	{
		return;
	}
	else if(vle_mode_is(VIEW_MODE))
	{
		view_post();
		return;
	}
	else if(is_in_menu_like_mode())
	{
		menu_post();
		return;
	}

	update_screen(curr_stats.need_update);

	if(curr_stats.save_msg)
	{
		status_bar_message(NULL);
	}

	if(!vle_mode_is(FILE_INFO_MODE) && curr_view->list_rows > 0)
	{
		if(!is_status_bar_multiline())
		{
			update_stat_window(curr_view);
			ui_ruler_update(curr_view);
		}
	}

	modes_statusbar_update();
}
Ejemplo n.º 8
0
/*
 * Dump SPX statistics structure.
 */
void
spx_stats(u_long off, const char *name, int af1 __unused, int proto __unused)
{
	struct spx_istat spx_istat;
#define	spxstat spx_istat.newstats

	if (off == 0)
		return;
	kread(off, (char *)&spx_istat, sizeof (spx_istat));
	printf("%s:\n", name);
	ANY(spx_istat.nonucn, "connection", " dropped due to no new sockets ");
	ANY(spx_istat.gonawy, "connection", " terminated due to our end dying");
	ANY(spx_istat.nonucn, "connection",
	    " dropped due to inability to connect");
	ANY(spx_istat.noconn, "connection",
	    " dropped due to inability to connect");
	ANY(spx_istat.notme, "connection",
	    " incompleted due to mismatched id's");
	ANY(spx_istat.wrncon, "connection", " dropped due to mismatched id's");
	ANY(spx_istat.bdreas, "packet", " dropped out of sequence");
	ANY(spx_istat.lstdup, "packet", " duplicating the highest packet");
	ANY(spx_istat.notyet, "packet", " refused as exceeding allocation");
	ANYl(spxstat.spxs_connattempt, "connection", " initiated");
	ANYl(spxstat.spxs_accepts, "connection", " accepted");
	ANYl(spxstat.spxs_connects, "connection", " established");
	ANYl(spxstat.spxs_drops, "connection", " dropped");
	ANYl(spxstat.spxs_conndrops, "embryonic connection", " dropped");
	ANYl(spxstat.spxs_closed, "connection", " closed (includes drops)");
	ANYl(spxstat.spxs_segstimed, "packet", " where we tried to get rtt");
	ANYl(spxstat.spxs_rttupdated, "time", " we got rtt");
	ANYl(spxstat.spxs_delack, "delayed ack", " sent");
	ANYl(spxstat.spxs_timeoutdrop, "connection",
	    " dropped in rxmt timeout");
	ANYl(spxstat.spxs_rexmttimeo, "retransmit timeout", "");
	ANYl(spxstat.spxs_persisttimeo, "persist timeout", "");
	ANYl(spxstat.spxs_keeptimeo, "keepalive timeout", "");
	ANYl(spxstat.spxs_keepprobe, "keepalive probe", " sent");
	ANYl(spxstat.spxs_keepdrops, "connection", " dropped in keepalive");
	ANYl(spxstat.spxs_sndtotal, "total packet", " sent");
	ANYl(spxstat.spxs_sndpack, "data packet", " sent");
	ANYl(spxstat.spxs_sndbyte, "data byte", " sent");
	ANYl(spxstat.spxs_sndrexmitpack, "data packet", " retransmitted");
	ANYl(spxstat.spxs_sndrexmitbyte, "data byte", " retransmitted");
	ANYl(spxstat.spxs_sndacks, "ack-only packet", " sent");
	ANYl(spxstat.spxs_sndprobe, "window probe", " sent");
	ANYl(spxstat.spxs_sndurg, "packet", " sent with URG only");
	ANYl(spxstat.spxs_sndwinup, "window update-only packet", " sent");
	ANYl(spxstat.spxs_sndctrl, "control (SYN|FIN|RST) packet", " sent");
	ANYl(spxstat.spxs_sndvoid, "request", " to send a non-existant packet");
	ANYl(spxstat.spxs_rcvtotal, "total packet", " received");
	ANYl(spxstat.spxs_rcvpack, "packet", " received in sequence");
	ANYl(spxstat.spxs_rcvbyte, "byte", " received in sequence");
	ANYl(spxstat.spxs_rcvbadsum, "packet", " received with ccksum errs");
	ANYl(spxstat.spxs_rcvbadoff, "packet", " received with bad offset");
	ANYl(spxstat.spxs_rcvshort, "packet", " received too short");
	ANYl(spxstat.spxs_rcvduppack, "duplicate-only packet", " received");
	ANYl(spxstat.spxs_rcvdupbyte, "duplicate-only byte", " received");
	ANYl(spxstat.spxs_rcvpartduppack, "packet",
	    " with some duplicate data");
	ANYl(spxstat.spxs_rcvpartdupbyte, "dup. byte", " in part-dup. packet");
	ANYl(spxstat.spxs_rcvoopack, "out-of-order packet", " received");
	ANYl(spxstat.spxs_rcvoobyte, "out-of-order byte", " received");
	ANYl(spxstat.spxs_rcvpackafterwin, "packet", " with data after window");
	ANYl(spxstat.spxs_rcvbyteafterwin, "byte", " rcvd after window");
	ANYl(spxstat.spxs_rcvafterclose, "packet", " rcvd after 'close'");
	ANYl(spxstat.spxs_rcvwinprobe, "rcvd window probe packet", "");
	ANYl(spxstat.spxs_rcvdupack, "rcvd duplicate ack", "");
	ANYl(spxstat.spxs_rcvacktoomuch, "rcvd ack", " for unsent data");
	ANYl(spxstat.spxs_rcvackpack, "rcvd ack packet", "");
	ANYl(spxstat.spxs_rcvackbyte, "byte", " acked by rcvd acks");
	ANYl(spxstat.spxs_rcvwinupd, "rcvd window update packet", "");
}
Ejemplo n.º 9
0
int main(void)
{
   athrow(ANY());
   return 0;
}
Ejemplo n.º 10
0
int
is_in_menu_like_mode(void)
{
	return ANY(vle_primary_mode_is, MENU_MODE, FILE_INFO_MODE);
}
Ejemplo n.º 11
0
    DEVICE void operator() (
        vec3f*                                          aRayOrg,
        vec3f*                                          aRayDir,
        const tControlStructure&                        aGridParameters,
        const tStorageStructure&                        aScene,
        const tMaterialStorageStructure&                aMaterialStorage,
        const tLightSource&                             aLightSource,
        vec3f&                                          oRadiance,
        uint*                                           aSharedMem,
        int                                             aSeed = 0)
    {
        //////////////////////////////////////////////////////////////////////////
        //Traversal initialization
        t_Traverser     traverser;
        t_State         state;

        //////////////////////////////////////////////////////////////////////////
        //Integration Initialization
        CosineHemisphereSampler genDir;
        t_RNG genRand(  12872141u + aSeed * 426997u + aSeed,
            2611909u + aSeed * 14910827u + globalThreadId1D(1887143u) + aSeed,
            1010567u + aSeed * 2757577u + globalThreadId1D(45751u) + aSeed,
            416191069u);
        //t_RNG genRand(globalThreadId1D() + RESX * RESY * (*aImageId));

#ifndef GATHERSTATISTICS
        oRadiance = vec3f::rep(1.f);
#else
        oRadiance.x = 1.f; //number of rays traced
        oRadiance.y = 0.f; //number of rays active after path termination
        oRadiance.z = 0.f; //number of intersection tests
#endif

        //////////////////////////////////////////////////////////////////////////
        //Integration loop
        float rayT   = FLT_MAX;
        uint  bestHit;

        //NOTE: Device capability 1.2 or higher required
        while (ANY(rayT > 0.f))//Termination criteria
        {
#ifndef GATHERSTATISTICS
            traverser.traverse(aRayOrg, aRayDir, rayT, bestHit, state,
                aGridParameters, aScene, aSharedMem);
#else
            traverser.traverse(aRayOrg, aRayDir, rayT, bestHit, state,
                aGridParameters, aScene, aSharedMem, oRadiance);

            oRadiance.y += 1.f;
#endif
            if ((rayT < FLT_MAX) && (rayT > 0.f))
            {
                bestHit = aScene.indices[bestHit];
                vec3f normal = aScene(bestHit).vertices[0];
                //register reuse: state.tMax should be edge1
                state.tMax = aScene(bestHit).vertices[1];
                //register reuse: state.cellId should be edge2
                state.cellId = aScene(bestHit).vertices[2];

                state.tMax = state.tMax - normal;
                state.cellId = state.cellId - normal;

                normal = ~(state.tMax % state.cellId);
                state.tMax = ~state.tMax;
                state.cellId = normal % state.tMax;

                //vec3f::getLocalCoordinates(normal, state.tMax, state.cellId);

                if (normal.dot(aRayDir[threadId1D()]) > 0.f)
                {
                    normal = -normal;
                }

                float4 diffReflectance = aMaterialStorage.getDiffuseReflectance(
                    aScene.getMaterialId(bestHit));
                //float albedo = (diffReflectance.x * 0.222f +
                //    diffReflectance.y * 0.7067f +
                //    diffReflectance.z * 0.0713f);
                float albedo = 0.5f;
                float rnum = genRand();

                if( rnum < albedo )
                {
#ifndef GATHERSTATISTICS
                    oRadiance = oRadiance / albedo;
                    //pi is to account for cosine weighted hemisphere sampling
                    oRadiance.x = oRadiance.x * diffReflectance.x * M_PI;
                    oRadiance.y = oRadiance.y * diffReflectance.y * M_PI;
                    oRadiance.z = oRadiance.z * diffReflectance.z * M_PI;
#else
                    oRadiance.x += 1.f;
#endif
                    //generate new ray
                    aRayOrg[threadId1D()] = aRayOrg[threadId1D()]
                    + rayT * aRayDir[threadId1D()] + normal *  0.001f;

                    vec3f randDir = genDir(genRand(), genRand());
                    aRayDir[threadId1D()] = state.tMax * randDir.x +
                        state.cellId * randDir.y + normal * randDir.z;

                    rayT = FLT_MAX;
                }
                else
                {
                    //terminate path and save last hit-point
                    aRayDir[threadId1D()] = aRayOrg[threadId1D()]
                    + (rayT - 0.001f) * aRayDir[threadId1D()];
#ifndef GATHERSTATISTICS
                    oRadiance.x = oRadiance.x * diffReflectance.x / (1 - albedo);
                    oRadiance.y = oRadiance.y * diffReflectance.y / (1 - albedo);
                    oRadiance.z = oRadiance.z * diffReflectance.z / (1 - albedo);
#endif
                    //save cos between normal and incoming direction
                    aRayOrg[threadId1D()] = normal;

                    rayT = -1.f;
                }
            }
            else if (rayT > 0.f)
            {
#ifndef GATHERSTATISTICS
                //terminate path
                oRadiance.x = oRadiance.x * BACKGROUND_R;
                oRadiance.y = oRadiance.y * BACKGROUND_G;
                oRadiance.z = oRadiance.z * BACKGROUND_B;
#endif
                rayT = -2.f;
            }//end if (rayT < FLT_MAX) && (rayT > 0.f)
        }
        //end integration loop
        //////////////////////////////////////////////////////////////////////////
        //trace ray to light source

        //register reuse state.cellId.x should be vec3f surfaceNormal
        state.cellId = aRayOrg[threadId1D()];

        aRayOrg[threadId1D()] = aLightSource.getPoint(genRand(), genRand());
        aRayDir[threadId1D()] = aRayDir[threadId1D()] - aRayOrg[threadId1D()];

        if (rayT > -2.f)
        {
            rayT = FLT_MAX;
#ifndef GATHERSTATISTICS
            oRadiance = oRadiance * max(0.f, -state.cellId.dot(~aRayDir[threadId1D()]));
#endif
        }

#ifndef GATHERSTATISTICS
        traverser.traverseShadowRay(aRayOrg, aRayDir, rayT, bestHit, state,
            aGridParameters, aScene, aSharedMem);

        if (rayT >= 0.9999f)
        {
            float attenuation = aRayDir[threadId1D()].dot(aRayDir[threadId1D()]);
            oRadiance = oRadiance *
                aLightSource.intensity *
                dcLightSource.getArea() *
                max(0.f, aLightSource.normal.dot(~aRayDir[threadId1D()])) /
                attenuation;
            //oRadiance = oRadiance / aRayDir[threadId1D()].len() / aRayDir[threadId1D()].len() * max(0.f, aLightSource.normal.dot(aRayDir[threadId1D()]));


        }
        else if (rayT > -2.f)
        {
            //occluded
            oRadiance = vec3f::rep(0.f);
        }
#else
        traverser.traverseShadowRay(aRayOrg, aRayDir, rayT, bestHit, state,
             aGridParameters, aScene, aSharedMem, oRadiance);
        
        oRadiance.x += 1.f;
        oRadiance.y += 1.f;
#endif

    }
Ejemplo n.º 12
0
WireSyntax::WireSyntax()
{
    SYNTAX("Wire");

    DEFINE_VOID("Comment",
                CHOICE(
                    GLUE(
                        STRING("//"),
                        CHOICE(
                            FIND(AHEAD(CHAR('\n'))),
                            FIND(EOI())
                        )
                    ),
                    GLUE(
                        STRING("/*"),
                        REPEAT(
                            CHOICE(
                                INLINE("Comment"),
                                GLUE(
                                    NOT(STRING("*/")),
                                    ANY()
                                )
                            )
                        ),
                        STRING("*/")
                    )
                )
               );

    DEFINE_VOID("Whitespace",
                REPEAT(
                    CHOICE(
                        RANGE(" \t\n"),
                        INLINE("Comment")
                    )
                )
               );

    DEFINE("Name",
           REPEAT(1, EXCEPT(" \t\n:;"))
          );

    DEFINE("Value",
           CHOICE(
               REF("Atom"),
               REF("Properties"),
               REF("Items")
           )
          );

    DEFINE("Object",
           GLUE(
               REPEAT(0, 1,
                      GLUE(
                          REF("Name"),
                          INLINE("Whitespace"),
                          CHAR(':'),
                          INLINE("Whitespace")
                      )
                     ),
               INLINE("Value")
           )
          );

    DEFINE("Atom",
           REPEAT(
               GLUE(
                   NOT(
                       CHOICE(
                           GLUE(
                               REPEAT(RANGE(" \t")),
                               INLINE("Name"),
                               REPEAT(RANGE(" \t")),
                               CHAR(':')
                           ),
                           GLUE(
                               REPEAT(RANGE(" \t")),
                               RANGE("};,")
                           ),
                           STRING("\n\n")
                       )
                   ),
                   ANY()
               )
           )
          );

    DEFINE("Properties",
           GLUE(
               CHAR('{'),
               INLINE("Whitespace"),
               REPEAT(
                   GLUE(
                       REF("Object"),
                       INLINE("Whitespace"),
                       RANGE(";,"),
                       INLINE("Whitespace")
                   )
               ),
               CHAR('}')
           )
          );

    DEFINE("Items",
           GLUE(
               CHAR('['),
               INLINE("Whitespace"),
               REPEAT(
                   GLUE(
                       REF("Value"),
                       INLINE("Whitespace"),
                       RANGE(";,"),
                       INLINE("Whitespace")
                   )
               ),
               CHAR(']')
           )
          );

    ENTRY("Object");
}
Ejemplo n.º 13
0
Archivo: main.cpp Proyecto: tynn/H4KvT
int main(int argc, char **argv)
{
	Vals vals;

	/* the application */
	QApplication app(argc, argv);
	app.setApplicationName(APP_NAME);
	app.setWindowIcon(QIcon(":/icon"));
	Window window;

	/* translations */
	QTranslator qtr;
	if (qtr.load("qt_" + QLocale::system().name(), QTR_PATH))
		app.installTranslator(&qtr);

	QTranslator htr;
	if (htr.load("H4KvT_" + QLocale::system().name(), ":/"))
		app.installTranslator(&htr);

	/* display information */
	QTextEdit *text = new QTextEdit;
	text->setReadOnly(true);
	text->setLineWrapMode(QTextEdit::NoWrap);
	text->setToolTip(Window::tr("Drop any file for hashing"));
	QObject::connect(&window, &Window::idle, text, &QWidget::setEnabled);

	/* compare hash */
	QLineEdit *test = new QLineEdit;
	HexVal hexval;
	test->setValidator(&hexval);
	test->installEventFilter(&window);
	test->setToolTip(Window::tr("Compare hashes"));

	QObject::connect(test, &QLineEdit::textChanged,
		[&](const QString &newValue) { if (vals.name != "") {
			std::string hashVal = newValue.toStdString();
			std::transform(hashVal.begin(), hashVal.end(), hashVal.begin(), ::tolower);
			std::stringstream html;
			if (hashVal != "")
				html << "<style>.h" << hashVal << "{color:green}</style>";
			html << "<div style='margin-bottom:2; font-size:27px'><i><b>" << vals.name << "</b></i></div>";
			html << "<div style='margin-bottom:7; margin-left:23; font-size:13px'>" << vals.path << "</div>";
			if (!ALL(vals,"")) {
				html << "<div style='font-size:13px'><table>";
				if (vals.md5 != "")
					html << "<tr><td>md5: </td><td class='h" << vals.md5 << "'>" << vals.md5 << "</td</tr>";
				if (vals.sha1 != "")
					html << "<tr><td>sha1: </td><td class='h" << vals.sha1 << "'>" << vals.sha1 << "</td</tr>";
				if (vals.sha224 != "")
					html << "<tr><td>sha224: </td><td class='h" << vals.sha224 << "'>" << vals.sha224 << "</td</tr>";
				if (vals.sha256 != "")
					html << "<tr><td>sha256: </td><td class='h" << vals.sha256 << "'>" << vals.sha256 << "</td</tr>";
				if (vals.sha384 != "")
					html << "<tr><td>sha384: </td><td class='h" << vals.sha384 << "'>" << vals.sha384 << "</td</tr>";
				if (vals.sha512 != "")
					html << "<tr><td>sha512: </td><td class='h" << vals.sha512 << "'>" << vals.sha512 << "</td</tr>";
				html << "</table></div>";
			}
			int horizontal = text->horizontalScrollBar()->value();
			int vertical = text->verticalScrollBar()->value();
			text->setHtml(QString::fromStdString(html.str()));
			text->horizontalScrollBar()->setValue(horizontal);
			text->verticalScrollBar()->setValue(vertical);
			test->setStyleSheet(ANY(vals,hashVal) ? "color:green" : "");
		}});

	/* error messages */
	QLabel *error = new QLabel;
	error->setStyleSheet("color:red");

	/* test or error */
	QStackedWidget *stack = new QStackedWidget;
	delete stack->layout();
	stack->setLayout(new Stack);
	stack->addWidget(error);
	stack->addWidget(test);
	stack->setCurrentIndex(1);

	/* toggle test or error */
	QPushButton *hash = new QPushButton(QIcon(":/icon"), "");
	hash->setCheckable(true);
	hash->setChecked(true);
	hash->setToolTip(Window::tr("Compare hashes"));
	QObject::connect(hash, &QPushButton::toggled, stack, &QStackedWidget::setCurrentIndex);

	/* store method */
	QSettings settings("H4KvT", "H4KvT");

	/* more methods */
	bool more;
	try {
		settings.setValue("MoreHashingMethods", more = moreOrLess());
	} catch (...) {
		more = settings.value("MoreHashingMethods", false).toBool();
	}

	/* hashing method */
	QComboBox *meth = new QComboBox;
	meth->addItem("md5");
	meth->addItem("sha1");
	if (more) meth->addItem("sha224");
	meth->addItem("sha256");
	if (more) meth->addItem("sha384");
	meth->addItem("sha512");
	meth->setToolTip(Window::tr("Hashing method"));
	meth->setCurrentText(settings.value("HashingMethod", "md5").toString());
	QObject::connect(&window, &Window::idle, meth, &QWidget::setEnabled);

	QObject::connect(meth, &QComboBox::currentTextChanged,
		[&](const QString &text) { settings.setValue("HashingMethod", text); });

	/* toolbar */
	QHBoxLayout *pane = new QHBoxLayout;
	pane->addWidget(hash, 0, Qt::AlignLeft);
	pane->addWidget(stack);
	pane->addWidget(meth, 0, Qt::AlignRight);

	/* main layout */
	QVBoxLayout *layout = new QVBoxLayout;
	layout->addWidget(text);
	layout->addLayout(pane);

	/* the window */
	window.centralWidget()->setLayout(layout);
	window.show();

	/* future hashing */
	QFutureWatcher<Vals> zu;
	QObject::connect(&zu, &QFutureWatcher<Vals>::finished,
		[&]() {
			Vals valsi = zu.future().result();
			window.idle(true);
			if (valsi.path == "") {
				error->setText(QString::fromStdString(valsi.name));
				hash->setChecked(false);
			} else {
				error->clear();
				vals += valsi;
				test->textChanged(test->text());
			}
		});

	QObject::connect(meth, &QComboBox::currentTextChanged,
		[&](const QString &text) { if (vals.name != "") {
			window.idle(false);
			zu.setFuture(QtConcurrent::run(&update, text, vals));
		}});

	QObject::connect(&window, &Window::fileDroped,
		[&](const QString &name, const QString &path) {
			window.idle(false);
			zu.setFuture(QtConcurrent::run(&update, meth->currentText(), Vals(name, path)));
		});

	/* hashing info */
	QGraphicsBlurEffect blur;
	blur.setBlurHints(QGraphicsBlurEffect::AnimationHint);

	QPropertyAnimation anim(&blur, "blurRadius");
	anim.setDuration(2000);
	anim.setLoopCount(-1);
	anim.setKeyValueAt(0, 0);
	anim.setKeyValueAt(0.5, 3);
	anim.setKeyValueAt(1, 0);

	QLabel *hashing = new QLabel;
	hashing->setPixmap(QPixmap(":/icon"));
	hashing->setAttribute(Qt::WA_TransparentForMouseEvents);
	hashing->setGraphicsEffect(&blur);
	hashing->hide();
	(new QHBoxLayout(text))->addWidget(hashing, 0, Qt::AlignCenter);

	QObject::connect(&blur, &QGraphicsBlurEffect::blurRadiusChanged,
		hashing, static_cast<void(QWidget::*)()>(&QWidget::update));

	QObject::connect(&window, &Window::idle,
		[&](bool idle) {
			if (idle) {
				hashing->hide();
				anim.stop();
			} else {
				hashing->show();
				anim.start();
			}
		});

	/* about app */
	QMenu about;
	QAction *action = about.addAction(QIcon(":/icon"), Window::tr("About %1").arg(APP_NAME));
	action->setMenuRole(QAction::AboutRole);
	QObject::connect(action, &QAction::triggered, &window, &Window::about);

	error->setContextMenuPolicy(Qt::NoContextMenu);
	hash->setContextMenuPolicy(Qt::NoContextMenu);
	meth->setContextMenuPolicy(Qt::NoContextMenu);
	window.setContextMenuPolicy(Qt::CustomContextMenu);
	QObject::connect(&window, &QWidget::customContextMenuRequested,
		[&about, &window](const QPoint &pos) { about.popup(window.mapToGlobal(pos)); });

	text->setContextMenuPolicy(Qt::CustomContextMenu);
	QObject::connect(text, &QWidget::customContextMenuRequested,
		[action, text](const QPoint &pos) {
			if (QMenu *m = text->createStandardContextMenu()) {
				m->insertAction(m->insertSeparator(m->actions()[0]), action);
				m->popup(text->mapToGlobal(pos));
			}
		});

	test->setContextMenuPolicy(Qt::CustomContextMenu);
	QObject::connect(test, &QWidget::customContextMenuRequested,
		[action, test](const QPoint &pos) {
			if (QMenu *m = test->createStandardContextMenu()) {
				m->insertAction(m->insertSeparator(m->actions()[0]), action);
				m->popup(test->mapToGlobal(pos));
			}
		});

	return app.exec();
}
Ejemplo n.º 14
0
HaxeMessageSyntax::HaxeMessageSyntax()
{
	DEFINE_VOID("SpaceChar", RANGE(" \n\r\t"));
	DEFINE_VOID("Whitespace", REPEAT(INLINE("SpaceChar")));
	
	specialChar_ =
		DEFINE("SpecialChar",
			GLUE(
				CHAR('&'),
				KEYWORD("gt lt"),
				CHAR(';')
			)
		);
	gt_ = keywordByName("gt");
	lt_ = keywordByName("lt");
	
	value_ =
		DEFINE("Value",
			REPEAT(1,
				CHOICE(
					REF("SpecialChar"),
					GLUE(
						NOT(
							GLUE(
								INLINE("Whitespace"),
								CHAR('<')
							)
						),
						ANY()
					)
				)
			)
		);
	
	typeTip_ =
		DEFINE("TypeTip",
			GLUE(
				STRING("<type>"),
				INLINE("Whitespace"),
				REF("Value"),
				INLINE("Whitespace"),
				STRING("</type>")
			)
		);
	
	memberName_ = DEFINE("MemberName", REPEAT(1, OTHER('\"')));
	memberType_ = DEFINE("MemberType", REPEAT(0, 1, INLINE("Value")));
	memberDescription_ = DEFINE("MemberDescription", REPEAT(0, 1, INLINE("Value")));
	
	member_ =
		DEFINE("Member",
			GLUE(
				STRING("<i n=\""),
				REF("MemberName"),
				STRING("\"><t>"),
				REF("MemberType"),
				STRING("</t><d>"),
				REF("MemberDescription"),
				STRING("</d></i>")
			)
		);
	
	membersTip_ =
		DEFINE("MembersTip",
			GLUE(
				STRING("<list>"),
				REPEAT(1,
					GLUE(
						INLINE("Whitespace"),
						REF("Member")
					)
				),
				INLINE("Whitespace"),
				STRING("</list>")
			)
		);
	
	haxeTip_ =
		DEFINE("HaxeTip",
			FIND(
				GLUE(
					INLINE("Whitespace"),
					CHOICE(
						REF("TypeTip"),
						REF("MembersTip")
					),
					INLINE("Whitespace")
				)
			)
		);
	
	ENTRY("HaxeTip");
}
Ejemplo n.º 15
0
    DEVICE void operator() (
        vec3f*                                          aRayOrg,
        vec3f*                                          aRayDir,
        const tControlStructure&                        aGridParameters,
        const tStorageStructure&                        aScene,
        const tMaterialStorageStructure&                aMaterialStorage,
        const tLightSource&                             aLightSource,
        vec3f&                                          oRadiance,
        uint*                                           aSharedMem,
        int                                             aSeed = 0)
    {
        //////////////////////////////////////////////////////////////////////////
        //Traversal initialization
        t_Traverser     traverser;
        t_State         state;

        //////////////////////////////////////////////////////////////////////////
        //Integration Initialization
        CosineHemisphereSampler genDir;
        t_RNG genRand(  1236789u + globalThreadId1D(),
                        369u + globalThreadId1D(aSeed),
                        351288629u + globalThreadId1D(aSeed),
                        416191069u );
        //t_RNG genRand(globalThreadId1D() + RESX * RESY * (*aImageId));

#ifndef GATHERSTATISTICS
        oRadiance = vec3f::rep(1.f);
#else
        oRadiance.x = 1.f; //number of rays traced
        oRadiance.y = 0.f; //number of rays active after path termination
        oRadiance.z = 0.f; //number of intersection tests
#endif

        //////////////////////////////////////////////////////////////////////////
        //Integration loop
        float rayT   = FLT_MAX;
        uint  bestHit;
        uint bounceCount = 0u;

        //NOTE: Device capability 1.2 or higher required
        while (ANY(rayT > 0.f))//Termination criteria
        {
#ifndef GATHERSTATISTICS
            traverser.traverse(aRayOrg, aRayDir, rayT, bestHit, state,
                               aGridParameters, aScene, aSharedMem);
#else
            traverser.traverse(aRayOrg, aRayDir, rayT, bestHit, state,
                               aGridParameters, aScene, aSharedMem, oRadiance);

            oRadiance.y += 1.f;
#endif
            if ((rayT < FLT_MAX) && (rayT > 0.f))
            {
                bestHit = aScene.indices[bestHit];
                vec3f normal = aScene(bestHit).vertices[0];
                //register reuse: state.tMax should be edge1
                state.tMax = aScene(bestHit).vertices[1];
                //register reuse: state.cellId should be edge2
                state.cellId = aScene(bestHit).vertices[2];

                state.tMax = state.tMax - normal;
                state.cellId = state.cellId - normal;

                normal = ~(state.tMax % state.cellId);
                state.tMax = ~state.tMax;
                state.cellId = normal % state.tMax;

                if (normal.dot(aRayDir[threadId1D()]) > 0.f)
                {
                    normal = -normal;
                }

                float4 diffReflectance = aMaterialStorage.getDiffuseReflectance(
                                             aScene.getMaterialId(bestHit));

                if( bounceCount < 1 )
                {

                    ++bounceCount;
#ifndef GATHERSTATISTICS

                    oRadiance.x = oRadiance.x * diffReflectance.x;
                    oRadiance.y = oRadiance.y * diffReflectance.y;
                    oRadiance.z = oRadiance.z * diffReflectance.z;
#else
                    oRadiance.x += 1.f;
#endif
                    //generate new ray
                    aRayOrg[threadId1D()] = aRayOrg[threadId1D()]
                                            + rayT * aRayDir[threadId1D()] + normal * EPS;

                    vec3f randDir = genDir(genRand(), genRand());
                    aRayDir[threadId1D()] = state.tMax * randDir.x +
                                            state.cellId * randDir.y + normal * randDir.z;

                    rayT = FLT_MAX;
                }
                else
                {
                    //terminate path and save last hit-point
                    aRayDir[threadId1D()] = aRayOrg[threadId1D()]
                                            + (rayT - 0.0001f) * aRayDir[threadId1D()];
#ifndef GATHERSTATISTICS
                    oRadiance.x = oRadiance.x * diffReflectance.x;
                    oRadiance.y = oRadiance.y * diffReflectance.y;
                    oRadiance.z = oRadiance.z * diffReflectance.z;
#endif
                    //save normal for later
                    aRayOrg[threadId1D()] = normal;

                    rayT = -1.f;
                }
            }
            else if (rayT > 0.f)
            {
#ifndef GATHERSTATISTICS
                //terminate path
                oRadiance.x = oRadiance.x * BACKGROUND_R;
                oRadiance.y = oRadiance.y * BACKGROUND_G;
                oRadiance.z = oRadiance.z * BACKGROUND_B;
#endif
                rayT = -2.f;
            }//end if (rayT < FLT_MAX) && (rayT > 0.f)
        }
        //end integration loop
        //////////////////////////////////////////////////////////////////////////
        //trace ray to light source

        //register reuse state.cellId should be vec3f surfaceNormal
        state.cellId = aRayOrg[threadId1D()];

        aRayOrg[threadId1D()] = aLightSource.getPoint(genRand(), genRand());
        aRayDir[threadId1D()] = aRayDir[threadId1D()] - aRayOrg[threadId1D()];

        if (rayT > -2.f)
        {
            rayT = FLT_MAX;
#ifndef GATHERSTATISTICS
            oRadiance = oRadiance * fabsf(state.cellId.dot(~aRayDir[threadId1D()]));
#endif
        }

#ifndef GATHERSTATISTICS
        traverser.traverseShadowRay(aRayOrg, aRayDir, rayT, bestHit, state,
                                    aGridParameters, aScene, aSharedMem);

        if (rayT >= 0.9999f)
        {
            oRadiance = oRadiance * aLightSource.intensity;
            oRadiance = oRadiance * max(0.f, aLightSource.normal.dot(~aRayDir[threadId1D()]));
        }
        else if (rayT > -2.f)
        {
            //occluded
            oRadiance = vec3f::rep(0.f);
        }
#else
        traverser.traverseShadowRay(aRayOrg, aRayDir, rayT, bestHit, state,
                                    aGridParameters, aScene, aSharedMem, oRadiance);

        oRadiance.x += 1.f;
        oRadiance.y += 1.f;
#endif
    }