QVariant Glissando::getProperty(P_ID propertyId) const
{
switch (propertyId) {
case P_ID::GLISS_TYPE:
return int(glissandoType());
case P_ID::GLISS_TEXT:
return text();
case P_ID::GLISS_SHOW_TEXT:
return showText();
case P_ID::GLISSANDO_STYLE:
return int(glissandoStyle());
case P_ID::PLAY:
return bool(playGlissando());
default:
break;
}
return SLine::getProperty(propertyId);
}
void OutputItemContentWidget::showTree()
{
if (!_isTreeModeSupported) {
// try to downgrade to text mode
showText();
return;
}
if (!_isTreeModeInitialized) {
_bsonTreeview = new BsonTreeView(_shell,_queryInfo);
BsonTreeModel *mod = new BsonTreeModel(_documents,_bsonTreeview);
_bsonTreeview->setModel(mod);
_stack->addWidget(_bsonTreeview);
_isTreeModeInitialized = true;
}
_stack->setCurrentWidget(_bsonTreeview);
}
void Room::muddaFiredAlienDevice() {
assert(_roomIndex >= 0 && _roomIndex <= 5);
const TextRef text[] = {
TX_MUD0_002, // These audio files aren't identical, but the text is mostly the same.
TX_MUD1_002,
TX_MUD2_002,
TX_MUD2_002, // Rooms 3-5 reuse MUD2
TX_MUD2_002,
TX_MUD2_002,
};
_awayMission->disableInput = false;
if (!_awayMission->mudd.discoveredLenseAndDegrimerFunction) {
_awayMission->mudd.discoveredLenseAndDegrimerFunction = true;
_awayMission->mudd.missionScore += 5; // BUGFIX: didn't happen if done in MUDD5
showText(TX_SPEAKER_KIRK, text[_roomIndex]);
}
}
void Room::muddaUseLenseOnDegrimer() {
assert(_roomIndex >= 0 && _roomIndex <= 5);
const TextRef text[] = {
TX_MUD0N011, // All of these audio files are identical, but there's one for each room.
TX_MUD1N013,
TX_MUD2N010,
TX_MUD3N016,
TX_MUD4N009,
TX_MUD5N009,
};
giveItem(OBJECT_IALIENDV);
loseItem(OBJECT_IDEGRIME);
loseItem(OBJECT_ILENSES);
_awayMission->mudd.missionScore++;
showText(text[_roomIndex]);
}
static void showBalloon(WScreen *scr)
{
int x, y;
Window foow;
unsigned foo, w;
scr->balloon->timer = NULL;
scr->balloon->ignoreTimer = 1;
if (!XGetGeometry(dpy, scr->balloon->objectWindow, &foow, &x, &y, &w, &foo, &foo, &foo)) {
scr->balloon->prevType = 0;
return;
}
if (wPreferences.miniwin_apercu_balloon && scr->balloon->apercu != None)
/* used to display either the apercu alone or the apercu and the title */
showApercu(scr, x, y, (wPreferences.icon_size - 1) * wPreferences.apercu_size,
(wPreferences.icon_size - 1) * wPreferences.apercu_size,
scr->balloon->text, scr->balloon->apercu);
else
showText(scr, x, y, scr->balloon->h, w, scr->balloon->text);
}
// Press the left/right arrow buttons to navigate through the examples.
void keyPressEvent(unsigned short ch, vl::EKey key)
{
BaseDemo::keyPressEvent(ch,key);
if (key == vl::Key_Left || key == vl::Key_Right)
{
if (key == vl::Key_Left)
mTest--;
if (key == vl::Key_Right)
mTest++;
if (mTest < 0) mTest = 3;
if (mTest > 3) mTest = 0;
sceneManager()->tree()->actors()->clear();
switch(mTest)
{
case 0: showSimplePipe(); break;
case 1: showFancyArch(); break;
case 2: showVortex(); break;
case 3: showNail(); break;
}
showText();
}
}
static void showBalloon(void *data)
{
char *text;
WMView *view = (WMView *) data;
Balloon *bPtr = view->screen->balloon;
int x, y;
Window foo;
bPtr->timer = NULL;
text = WMHashGet(bPtr->table, view);
if (!text)
return;
XTranslateCoordinates(view->screen->display, view->window, view->screen->rootWin, 0, 0, &x, &y, &foo);
if (!bPtr->view->flags.realized)
W_RealizeView(bPtr->view);
showText(bPtr, x, y, view->size.width, view->size.height, text);
bPtr->flags.noDelay = 1;
}
void OverlayHandler::showInfoText(bool show)
{
if(show) // show media info
{
if(refresh_timer == nullptr)
{
refresh_timer = new QTimer(this);
refresh_timer->setSingleShot(true);
connect(refresh_timer, &QTimer::timeout, // on timeout
[=] { showInfoText(); });
}
refresh_timer->start(OVERLAY_REFRESH_RATE);
showText(baka->mpv->getMediaInfo(),
QFont(Util::MonospaceFont(),
14, QFont::Bold), QColor(0xFFFF00),
QPoint(20, 20), 0, OVERLAY_INFO);
}
else // hide media info
{
delete refresh_timer;
refresh_timer = nullptr;
remove(OVERLAY_INFO);
}
}
void Room::tug3LookAtElasi4() {
if (_awayMission->tug.bridgeElasi4Status == GUARDSTAT_DEAD || _awayMission->tug.bridgeElasi2Status == GUARDSTAT_STUNNED)
showText(TX_TUG3N004);
else
showText(TX_TUG3N005);
}
void Room::tug3LookAtRedshirt() {
showText(TX_TUG3N001);
}
void Room::tug3LookAtSpock() {
showText(TX_TUG3N002);
}
void Room::tug3LookAtMccoy() {
showText(TX_TUG3N000);
}
void MainWindowTask::setup()
{
ui->setupUi(this);
ui->treeView->setContextMenuPolicy(Qt::CustomContextMenu);
settings = new QSettings("NIISI RAS","Kumir 1.9");
setWindowIcon(QIcon(":/taskEdit.ico"));
settings->setIniCodec("UTF-8");
lastFiles=settings->value("RescentFiles").toStringList();
customMenu.hide();
connect(ui->loadCurs,SIGNAL(activated()),this,SLOT(loadCourse()));
connect(ui->actionSave,SIGNAL(activated()),this,SLOT(saveCourse()));
connect(ui->treeView,SIGNAL(clicked(QModelIndex)),this,SLOT(showText(QModelIndex)));
connect(ui->treeView,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(startEdit(QModelIndex)));
// connect(ui->do_task,SIGNAL(triggered()),this,SLOT(startTask()));
qDebug()<<"Check Connect tttttttttttttttttt";
//connect(ui->checkTask,SIGNAL(triggered()),this,SLOT(checkTask()));
//connect(ui->actionReset,SIGNAL(triggered()),this,SLOT(resetTask()));
connect(ui->actionClose,SIGNAL(triggered()),this,SLOT(Close()));
// connect(ui->actionTested,SIGNAL(triggered()),this,SLOT(returnTested()));
connect(ui->treeView,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(customContextMenuRequested(QPoint)));
customMenu.addAction(ui->actionAdd);
customMenu.addAction(ui->actionRemove);
customMenu.addAction(ui->actionEdit);
customMenu.addAction(ui->addDeep);
customMenu.addSeparator();
customMenu.addAction(ui->actionup);
customMenu.addAction(ui->actionDown);
customMenu.addAction(ui->actionMakeSection);
customMenu.addMenu(ui->menuMove);
connect(ui->zadRb,SIGNAL(clicked(bool)),this,SLOT(setType()));
connect(ui->nodeRb,SIGNAL(clicked(bool)),this,SLOT(setType()));
connect(ui->actionup,SIGNAL(triggered()),this,SLOT(moveUp()));
connect(ui->actionDown,SIGNAL(triggered()),this,SLOT(moveDown()));
connect(ui->actionAdd,SIGNAL(triggered()),this,SLOT(addTask()));
connect(ui->addDeep,SIGNAL(triggered()),this,SLOT(addDeepTask()));
connect(ui->actionSaveK,SIGNAL(triggered()),this,SLOT(saveKurs()));
connect(ui->actionSave,SIGNAL(triggered()),this,SLOT(saveKursAs()));
connect(ui->actionRemove,SIGNAL(triggered()),this,SLOT(deleteTask()));
connect(ui->actionMakeSection,SIGNAL(triggered()),this,SLOT(makeSection()));
newDialog=new newKursDialog();
connect(ui->actionNewK,SIGNAL(triggered()),this,SLOT(newKurs()));
editDialog = new EditDialog(this);
connect(ui->actionEdit,SIGNAL(triggered()),this,SLOT(editTask()));
//ui->menuKurs->menuAction()->setVisible(false);
// ui->menuKurs->menuAction()->setEnabled(false);
setEditTaskEnabled(false);
ui->treeView->setSelectionMode(QAbstractItemView::SingleSelection);
editRoot=new QLineEdit(ui->treeView);
editRoot->hide();
connect(editRoot,SIGNAL(editingFinished ()),this,SLOT(endRootEdit()));
connect(ui->remIspButt,SIGNAL(pressed()),this,SLOT(remSelIsp()));
connect(ui->addIspButt,SIGNAL(pressed()),this,SLOT(addIsp()));
connect(ui->ispList,SIGNAL(clicked(QModelIndex)),this,SLOT(showFields()));
connect(ui->fieldsList,SIGNAL(clicked(QModelIndex)),this,SLOT(fieldClick()));
connect(ui->remFieldButt,SIGNAL(pressed()),this,SLOT(remField()));
connect(ui->addFieldButt,SIGNAL(pressed()),this,SLOT(addField()));
connect(ui->actionS,SIGNAL(triggered()),this,SLOT(saveBaseKurs()));
connect(ui->selFileButt,SIGNAL(pressed()),this,SLOT(setPrg()));
connect(ui->prgEdit,SIGNAL(textChanged(QString)),this,SLOT(prgLineChange()));
connect(ui->editFButt,SIGNAL(pressed()),this,SLOT(editFile()));
connect(ui->menuMove,SIGNAL(aboutToShow()),this,SLOT(createMoveMenu()));
// QMessageBox::information( 0, "", trUtf8("Setup add "), 0,0,0);
ui->ispSel->addItem("Robot");
ui->ispSel->addItem(trUtf8("Водолей"));
ui->actionup->setIcon(QIcon(":/arrow_up.png"));
ui->actionDown->setIcon(QIcon(":/arrow_down.png"));
changed=false;
isTeacher=true;
onTask=false;
cursFile="";
createRescentMenu();
//ui->textBrowser->setVisible(false);
};
void Room::muddaTick() {
// This function deals with the atmosphere running out when the life support generator
// is malfunctioning.
// NOTE: This has been changed a bit; in the original, they would just walk to
// a position and stay standing, though the code indicates they were supposed to
// collapse after walking.
// To simplify things, and since it makes more sense, now they'll just collapse on the
// spot instead.
assert(_roomIndex >= 0 && _roomIndex <= 5);
/*
// Unused: The positions to they originally walked to before collapsing.
const Common::Point deathPositions[][4] = {
{ Common::Point(0xbb, 0x8d), Common::Point(0xd0, 0x89), Common::Point(0xaa, 0x85), Common::Point(0xbf, 0x83) },
{ Common::Point(0xaa, 0xa5), Common::Point(0x83, 0xac), Common::Point(-1, -1), Common::Point(-1, -1) },
{ Common::Point(0x108, 0xbb), Common::Point(0x118, 0xc4), Common::Point(0xfe, 0xb2), Common::Point(0x117, 0xae) },
{ Common::Point(0xf1, 0x95), Common::Point(0xcd, 0x87), Common::Point(0xec, 0x84), Common::Point(0x110, 0xa6) },
{ Common::Point(0x8b, 0xb6), Common::Point(0x69, 0xb7), Common::Point(-1, -1), Common::Point(-1, -1) },
{ Common::Point(0x8b, 0xac), Common::Point(0x6f, 0x99), Common::Point(-1, -1), Common::Point(-1, -1) },
};
*/
const TextRef deathText[] = { // All of these audio files are identical, but there's one for each room.
TX_MUD0N006, TX_MUD1N007, TX_MUD2N005, TX_MUD3N008, TX_MUD4N005, TX_MUD5N105
};
// UNUSED: something similar to "deathText" which would also fit in this situation.
/*
const TextRef deathText2[] = { // All of these audio files are identical, but there's one for each room.
TX_MUD0N009, TX_MUD1N010, TX_MUD2N009, TX_MUD3N013, TX_MUD4N007, TX_MUD5N007
};
*/
const int TIMER_LENGTH = 27000;
if (_awayMission->mudd.lifeSupportMalfunctioning) {
if (!_awayMission->mudd.startedLifeSupportTimer) {
_awayMission->mudd.startedLifeSupportTimer = true;
_awayMission->mudd.lifeSupportTimer = TIMER_LENGTH;
}
_awayMission->mudd.lifeSupportTimer--;
// BUGFIX: the warnings at 75%, 50%, and 25% were only voiced in MUDD0.
if (_awayMission->mudd.lifeSupportTimer == (int)(TIMER_LENGTH * 0.25))
showText(TX_SPEAKER_SPOCK, TX_MUD0_018);
else if (_awayMission->mudd.lifeSupportTimer == (int)(TIMER_LENGTH * 0.5))
showText(TX_SPEAKER_SPOCK, TX_MUD0_019);
else if (_awayMission->mudd.lifeSupportTimer == (int)(TIMER_LENGTH * 0.75))
showText(TX_SPEAKER_SPOCK, TX_MUD0_020);
else if (_awayMission->mudd.lifeSupportTimer == 1) {
_awayMission->disableInput = true;
// In each room, the crewmen collapse in a different directions.
// NOTE: "kgetdn" (kirk, north) doesn't work properly; files in the animation
// are missing. It's replaced with 'e' (east) in MUDD1, MUDD3, MUDD5. Only
// applies to Kirk, others seem fine...
// TODO: check if this is the case across all versions...
const char *directions[] = {
"weseee", // KIRK
"sewene", // SPOCK
"nsesss", // MCCOY
"ewesww", // REDSHIRT
};
for (int i = OBJECT_KIRK; i <= OBJECT_REDSHIRT; i++) {
Common::String anim = getCrewmanAnimFilename(i, "getd");
anim += directions[i][_roomIndex];
loadActorAnim2(i, anim);
}
showText(deathText[_roomIndex]);
showGameOverMenu();
}
}
}
void TM1637Display::showNumber(float number,int decPlaces){
char buffer[7];
dtostrf(number, 0, decPlaces, buffer);
showText(buffer);
}
void TabBarItem::setText(const QString &AText)
{
if (FNotify.priority < 0)
showText(AText);
FText = AText;
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// camera parameters are Phi, Theta, R
gluLookAt(R * cos(Phi) * cos (Theta), R * sin (Theta), R * sin(Phi) * cos (Theta),
0.0,0.0,0.0, 0.0,1.0,0.0);
/* Lighting */
/* You are encouraged to change lighting parameters or make improvements/modifications
to the lighting model .
This way, you will personalize your assignment and your assignment will stick out.
*/
// global ambient light
GLfloat aGa[] = { 0.0, 0.0, 0.0, 0.0 };
// light 's ambient, diffuse, specular
GLfloat lKa0[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd0[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lKs0[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lKa1[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd1[] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat lKs1[] = { 1.0, 0.0, 0.0, 1.0 };
GLfloat lKa2[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd2[] = { 1.0, 1.0, 0.0, 1.0 };
GLfloat lKs2[] = { 1.0, 1.0, 0.0, 1.0 };
GLfloat lKa3[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd3[] = { 0.0, 1.0, 1.0, 1.0 };
GLfloat lKs3[] = { 0.0, 1.0, 1.0, 1.0 };
GLfloat lKa4[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd4[] = { 0.0, 0.0, 1.0, 1.0 };
GLfloat lKs4[] = { 0.0, 0.0, 1.0, 1.0 };
GLfloat lKa5[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd5[] = { 1.0, 0.0, 1.0, 1.0 };
GLfloat lKs5[] = { 1.0, 0.0, 1.0, 1.0 };
GLfloat lKa6[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd6[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lKs6[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat lKa7[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat lKd7[] = { 0.0, 1.0, 1.0, 1.0 };
GLfloat lKs7[] = { 0.0, 1.0, 1.0, 1.0 };
// light positions and directions
GLfloat lP0[] = { -1.999, -1.999, -1.999, 1.0 };
GLfloat lP1[] = { 1.999, -1.999, -1.999, 1.0 };
GLfloat lP2[] = { 1.999, 1.999, -1.999, 1.0 };
GLfloat lP3[] = { -1.999, 1.999, -1.999, 1.0 };
GLfloat lP4[] = { -1.999, -1.999, 1.999, 1.0 };
GLfloat lP5[] = { 1.999, -1.999, 1.999, 1.0 };
GLfloat lP6[] = { 1.999, 1.999, 1.999, 1.0 };
GLfloat lP7[] = { -1.999, 1.999, 1.999, 1.0 };
// jelly material color
GLfloat mKa[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat mKd[] = { 0.3, 0.3, 0.3, 1.0 };
GLfloat mKs[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mKe[] = { 0.0, 0.0, 0.0, 1.0 };
/* set up lighting */
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, aGa);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
// set up cube color
glMaterialfv(GL_FRONT, GL_AMBIENT, mKa);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mKd);
glMaterialfv(GL_FRONT, GL_SPECULAR, mKs);
glMaterialfv(GL_FRONT, GL_EMISSION, mKe);
glMaterialf(GL_FRONT, GL_SHININESS, 120);
// macro to set up light i
#define LIGHTSETUP(i)\
glLightfv(GL_LIGHT##i, GL_POSITION, lP##i);\
glLightfv(GL_LIGHT##i, GL_AMBIENT, lKa##i);\
glLightfv(GL_LIGHT##i, GL_DIFFUSE, lKd##i);\
glLightfv(GL_LIGHT##i, GL_SPECULAR, lKs##i);\
glEnable(GL_LIGHT##i)
LIGHTSETUP (0);
LIGHTSETUP (1);
LIGHTSETUP (2);
LIGHTSETUP (3);
LIGHTSETUP (4);
LIGHTSETUP (5);
LIGHTSETUP (6);
LIGHTSETUP (7);
// enable lighting
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
// show the cube
//showCube(&jello);
glDisable(GL_LIGHTING);
// show the bounding box
showBoundingBox();
// show Circle and Chain
showCircle();
showChain(&jello);
showText(&jello);
glutSwapBuffers();
}
void ApplicationMenuPage::makeTextNormal()
{
showText(2);
}
/*!
\overload
This is analogous to calling HbToolTip::showText(\a text, \a item,
item->boundingRect(), \a preferredAlignment)
*/
void HbToolTip::showText( const QString &text, QGraphicsItem *item,
Qt::Alignment preferredAlignment )
{
showText( text, item, item ? item->boundingRect() : QRectF(), preferredAlignment );
}
void GaussianFactorization(void)
{
BigInteger prime, q, r, M1, M2, Tmp;
struct sFactors *pstFactor;
BigIntMultiply(&ReValue, &ReValue, &tofactor);
BigIntMultiply(&ImValue, &ImValue, &Tmp);
BigIntAdd(&tofactor, &Tmp, &tofactor);
NbrFactorsNorm = 0;
#ifdef __EMSCRIPTEN__
originalTenthSecond = tenths();
#endif
if (tofactor.nbrLimbs == 1 && tofactor.limbs[0].x == 0)
{ // Norm is zero.
showText("<ul><li>Any gaussian prime divides this number</li></ul>");
return;
}
showText("<ul>");
if (tofactor.nbrLimbs > 1 || tofactor.limbs[0].x > 1)
{ // norm greater than 1. Factor norm.
int index, index2;
char *ptrFactorDec = tofactorDec;
NumberLength = tofactor.nbrLimbs;
CompressBigInteger(nbrToFactor, &tofactor);
strcpy(ptrFactorDec, "Re² + Im² = ");
ptrFactorDec += strlen(ptrFactorDec);
Bin2Dec(ReValue.limbs, ptrFactorDec, ReValue.nbrLimbs, groupLen);
ptrFactorDec += strlen(ptrFactorDec);
strcpy(ptrFactorDec, "² + ");
ptrFactorDec += strlen(ptrFactorDec);
Bin2Dec(ImValue.limbs, ptrFactorDec, ImValue.nbrLimbs, groupLen);
ptrFactorDec += strlen(ptrFactorDec);
strcpy(ptrFactorDec, "²");
ptrFactorDec += strlen(ptrFactorDec);
factor(&tofactor, nbrToFactor, factorsNorm, astFactorsNorm);
NbrFactorsNorm = astFactorsNorm[0].multiplicity;
pstFactor = &astFactorsNorm[1];
for (index = 0; index < NbrFactorsNorm; index++)
{
int *ptrPrime = pstFactor->ptrFactor;
NumberLength = *ptrPrime;
UncompressBigInteger(ptrPrime, &prime);
if (prime.nbrLimbs == 1 && prime.limbs[0].x == 2)
{ // Prime factor is 2.
for (index2 = 0; index2 < pstFactor->multiplicity; index2++)
{
M1.nbrLimbs = M2.nbrLimbs = 1;
M1.limbs[0].x = M2.limbs[0].x = 1;
M1.sign = SIGN_POSITIVE;
M2.sign = SIGN_NEGATIVE;
DivideGaussian(&M1, &M1); // Divide by 1+i
DivideGaussian(&M1, &M2); // Divide by 1-i
}
}
if ((prime.limbs[0].x & 2) == 0)
{ // Prime is congruent to 1 (mod 4)
CopyBigInt(&q, &prime);
NumberLength = prime.nbrLimbs;
memcpy(&TestNbr, prime.limbs, NumberLength * sizeof(limb));
TestNbr[NumberLength].x = 0;
GetMontgomeryParms(NumberLength);
subtractdivide(&q, 1, 4); // q = (prime-1)/4
memset(&K, 0, NumberLength * sizeof(limb));
memset(minusOneMont, 0, NumberLength * sizeof(limb));
SubtBigNbrModN(minusOneMont, MontgomeryMultR1, minusOneMont, TestNbr, NumberLength);
K[0].x = 1;
do
{ // Loop that finds mult1 = sqrt(-1) mod prime in Montgomery notation.
K[0].x++;
modPow(K, q.limbs, q.nbrLimbs, mult1.limbs);
} while (!memcmp(mult1.limbs, MontgomeryMultR1, NumberLength * sizeof(limb)) ||
!memcmp(mult1.limbs, minusOneMont, NumberLength * sizeof(limb)));
K[0].x = 1;
modmult(mult1.limbs, K, mult1.limbs); // Convert mult1 to standard notation.
UncompressLimbsBigInteger(mult1.limbs, &mult1); // Convert to Big Integer.
mult2.nbrLimbs = 1; // mult2 <- 1
mult2.limbs[0].x = 1;
mult2.sign = SIGN_POSITIVE;
for (;;)
{
// norm <- (mult1^2 + mult2^2) / prime
BigIntMultiply(&mult1, &mult1, &tofactor);
BigIntMultiply(&mult2, &mult2, &Tmp);
BigIntAdd(&tofactor, &Tmp, &Tmp);
BigIntDivide(&Tmp, &prime, &tofactor);
if (tofactor.nbrLimbs == 1 && tofactor.limbs[0].x == 1)
{ // norm equals 1.
break;
}
BigIntRemainder(&mult1, &tofactor, &M1);
BigIntRemainder(&mult2, &tofactor, &M2);
BigIntAdd(&M1, &M1, &Tmp);
BigIntSubt(&tofactor, &Tmp, &Tmp);
if (Tmp.sign == SIGN_NEGATIVE)
{
BigIntSubt(&M1, &tofactor, &M1);
}
BigIntAdd(&M2, &M2, &Tmp);
BigIntSubt(&tofactor, &Tmp, &Tmp);
if (Tmp.sign == SIGN_NEGATIVE)
{
BigIntSubt(&M2, &tofactor, &M2);
}
// Compute q <- (mult1*M1 + mult2*M2) / norm
BigIntMultiply(&mult1, &M1, &q);
BigIntMultiply(&mult2, &M2, &Tmp);
BigIntAdd(&q, &Tmp, &Tmp);
BigIntDivide(&Tmp, &tofactor, &q);
// Compute Mult2 <- (mult1*M2 - mult2*M1) / tofactor
BigIntMultiply(&mult1, &M2, &r);
BigIntMultiply(&mult2, &M1, &Tmp);
BigIntSubt(&r, &Tmp, &Tmp);
BigIntDivide(&Tmp, &tofactor, &mult2);
CopyBigInt(&mult1, &q);
mult1.sign = SIGN_POSITIVE; // mult1 <- abs(mult1)
mult2.sign = SIGN_POSITIVE; // mult2 <- abs(mult2)
} /* end while */
CopyBigInt(&M1, &mult1);
CopyBigInt(&M2, &mult2);
BigIntSubt(&M1, &M2, &Tmp);
if (Tmp.sign == SIGN_NEGATIVE)
{
CopyBigInt(&Tmp, &mult1);
CopyBigInt(&mult1, &mult2);
CopyBigInt(&mult2, &Tmp);
}
for (index2 = 0; index2 < pstFactor->multiplicity; index2++)
{
DivideGaussian(&mult1, &mult2);
BigIntNegate(&mult2, &Tmp);
DivideGaussian(&mult1, &Tmp);
}
} // end p = 1 (mod 4)
else
{ // if p = 3 (mod 4)
q.nbrLimbs = 1; // q <- 0
q.limbs[0].x = 0;
q.sign = SIGN_POSITIVE;
for (index2 = 0; index2 < pstFactor->multiplicity; index2++)
{
DivideGaussian(&prime, &q);
} // end p = 3 (mod 4)
}
pstFactor++;
}
}
// Process units: 1, -1, i, -i.
if (ReValue.nbrLimbs == 1 && ReValue.limbs[0].x == 1)
{
if (ReValue.sign == SIGN_POSITIVE)
{ // Value is 1.
if (NbrFactorsNorm == 0)
{
showText("No gaussian prime divides this number");
}
}
else
{ // Value is -1.
showText("<li>-1</li>");
}
}
else if (ImValue.sign == SIGN_POSITIVE)
{
showText("<li>i</li>");
}
else
{
showText("<li>-i</li>");
}
showText("</ul>");
}
void Room::tug3TalkToRedshirt() {
showText(TX_SPEAKER_CHRISTENSEN, TX_TUG3L003);
}
void ApplicationMenuPage::makeTextItalic()
{
showText(1);
}
void Room::tug3LookAnywhere() {
showText(TX_TUG3N007);
}
void MainWindowTask::startEdit(const QModelIndex & index )
{
showText(index);
editTask();
}
void TM1637Display::showText(String text){
int textLength = text.length() + 1;
char char_array[textLength];
text.toCharArray(char_array, textLength);
showText(char_array);
}
void DiscreteLogarithm(void)
{
BigInteger groupOrder, subGroupOrder, powSubGroupOrder, powSubGroupOrderBak;
BigInteger Exponent, runningExp, baseExp, mod;
BigInteger logar, logarMult, runningExpBase;
BigInteger currentExp;
int indexBase, indexExp;
int index, expon;
limb addA, addB, addA2, addB2;
limb mult1, mult2;
double magnitude, firstLimit, secondLimit;
long long brentK, brentR;
unsigned char EndPollardBrentRho;
int nbrLimbs;
struct sFactors *pstFactors;
enum eLogMachineState logMachineState;
char *ptr;
#ifdef __EMSCRIPTEN__
lModularMult = 0;
#endif
NumberLength = modulus.nbrLimbs;
if (!TestBigNbrEqual(&LastModulus, &modulus))
{
CompressBigInteger(nbrToFactor, &modulus);
Bin2Dec(modulus.limbs, tofactorDec, modulus.nbrLimbs, groupLen);
factor(&modulus, nbrToFactor, factorsMod, astFactorsMod, NULL);
NbrFactorsMod = astFactorsMod[0].multiplicity;
}
intToBigInteger(&DiscreteLog, 0); // DiscreteLog <- 0
intToBigInteger(&DiscreteLogPeriod, 1); // DiscreteLogPeriod <- 1
for (index = 1; index <= NbrFactorsMod; index++)
{
int mostSignificantDword, leastSignificantDword;
int NbrFactors;
int *ptrPrime;
int multiplicity;
ptrPrime = astFactorsMod[index].ptrFactor;
NumberLength = *ptrPrime;
UncompressBigInteger(ptrPrime, &groupOrder);
groupOrder.sign = SIGN_POSITIVE;
BigIntRemainder(&base, &groupOrder, &tmpBase);
if (tmpBase.nbrLimbs == 1 && tmpBase.limbs[0].x == 0)
{ // modulus and base are not relatively prime.
int ctr;
multiplicity = astFactorsMod[index].multiplicity;
CopyBigInt(&bigNbrA, &power);
for (ctr = multiplicity; ctr > 0; ctr--)
{
BigIntRemainder(&bigNbrA, &groupOrder, &bigNbrB);
if (bigNbrB.nbrLimbs != 1 || bigNbrB.limbs[0].x != 0)
{ // Exit loop if integer division cannot be performed
break;
}
BigIntDivide(&bigNbrA, &groupOrder, &bigNbrB);
CopyBigInt(&bigNbrA, &bigNbrB);
}
if (ctr == 0)
{ // Power is multiple of prime^exp.
continue;
}
// Compute prime^mutliplicity.
BigIntPowerIntExp(&groupOrder, multiplicity, &tmp2);
BigIntRemainder(&base, &tmp2, &tmpBase);
// Get tentative exponent.
ctr = multiplicity - ctr;
intToBigInteger(&bigNbrB, ctr); // Convert exponent to big integer.
NumberLength = tmp2.nbrLimbs;
memcpy(TestNbr, tmp2.limbs, (NumberLength + 1) * sizeof(limb));
GetMontgomeryParms(NumberLength);
BigIntModularPower(&tmpBase, &bigNbrB, &bigNbrA);
BigIntRemainder(&power, &tmp2, &bigNbrB);
BigIntSubt(&bigNbrA, &bigNbrB, &bigNbrA);
if (bigNbrA.nbrLimbs == 1 && bigNbrA.limbs[0].x == 0)
{
intToBigInteger(&DiscreteLog, ctr); // DiscreteLog <- exponent
intToBigInteger(&DiscreteLogPeriod, 0); // DiscreteLogPeriod <- 0
break;
}
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
else
{ // modulus and base are relatively prime.
BigIntRemainder(&power, &groupOrder, &bigNbrB);
if (bigNbrB.nbrLimbs == 1 && bigNbrB.limbs[0].x == 0)
{ // power is multiple of prime. Error.
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
}
CompressLimbsBigInteger(baseMontg, &tmpBase);
BigIntRemainder(&power, &groupOrder, &tmpBase);
CompressLimbsBigInteger(powerMontg, &tmpBase);
// Compute group order as the prime minus 1.
groupOrder.limbs[0].x--;
showText("Computing discrete logarithm...");
CompressBigInteger(nbrToFactor, &groupOrder);
factor(&groupOrder, nbrToFactor, factorsGO, astFactorsGO, NULL); // factor groupOrder.
NbrFactors = astFactorsGO[0].multiplicity;
NumberLength = *ptrPrime;
UncompressBigInteger(ptrPrime, &mod);
intToBigInteger(&logar, 0); // logar <- 0
intToBigInteger(&logarMult, 1); // logarMult <- 1
NumberLength = mod.nbrLimbs;
memcpy(TestNbr, mod.limbs, NumberLength * sizeof(limb));
TestNbr[NumberLength].x = 0;
// yieldFreq = 1000000 / (NumberLength*NumberLength);
GetMontgomeryParms(NumberLength);
#if 0
char *ptrText = textExp;
strcpy(ptrText, "<p>NumberLength (2) = ");
ptrText = ptrText + strlen(ptrText);
int2dec(&ptrText, NumberLength);
strcpy(ptrText, "</p>");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
#endif
// Convert base and power to Montgomery notation.
modmult(baseMontg, MontgomeryMultR2, baseMontg);
modmult(powerMontg, MontgomeryMultR2, powerMontg);
mostSignificantDword = NumberLength - 1;
if (NumberLength == 1)
{
leastSignificantDword = NumberLength - 1;
firstLimit = (double)TestNbr[leastSignificantDword].x / 3;
}
else
{
leastSignificantDword = NumberLength - 2;
firstLimit = ((double)TestNbr[mostSignificantDword].x * LIMB_RANGE +
TestNbr[leastSignificantDword].x) / 3;
}
secondLimit = firstLimit * 2;
for (indexBase = 0; indexBase < NbrFactors; indexBase++)
{
NumberLength = *astFactorsGO[indexBase + 1].ptrFactor;
UncompressBigInteger(astFactorsGO[indexBase + 1].ptrFactor, &subGroupOrder);
subGroupOrder.sign = SIGN_POSITIVE;
strcpy(textExp, "Computing discrete logarithm in subgroup of ");
Bin2Dec(subGroupOrder.limbs, textExp + strlen(textExp), subGroupOrder.nbrLimbs, groupLen);
ptr = textExp + strlen(textExp);
if (astFactorsGO[indexBase + 1].multiplicity > 1)
{
*ptr++ = '<';
*ptr++ = 's';
*ptr++ = 'u';
*ptr++ = 'p';
*ptr++ = '>';
int2dec(&ptr, astFactorsGO[indexBase + 1].multiplicity);
*ptr++ = '<';
*ptr++ = '/';
*ptr++ = 's';
*ptr++ = 'u';
*ptr++ = 'p';
*ptr++ = '>';
}
strcpy(ptr, " elements.");
showText(textExp);
NumberLength = mod.nbrLimbs;
memcpy(TestNbr, mod.limbs, NumberLength * sizeof(limb));
NumberLengthOther = subGroupOrder.nbrLimbs;
memcpy(TestNbrOther, subGroupOrder.limbs, NumberLengthOther * sizeof(limb));
TestNbr[NumberLength].x = 0;
GetMontgomeryParms(NumberLength);
nbrLimbs = subGroupOrder.nbrLimbs;
dN = (double)subGroupOrder.limbs[nbrLimbs - 1].x;
if (nbrLimbs > 1)
{
dN += (double)subGroupOrder.limbs[nbrLimbs - 2].x / LIMB_RANGE;
if (nbrLimbs > 2)
{
dN += (double)subGroupOrder.limbs[nbrLimbs - 3].x / LIMB_RANGE / LIMB_RANGE;
}
}
CopyBigInt(&baseExp, &groupOrder);
// Check whether base is primitive root.
BigIntDivide(&groupOrder, &subGroupOrder, &tmpBase);
modPow(baseMontg, tmpBase.limbs, tmpBase.nbrLimbs, primRootPwr);
if (!memcmp(primRootPwr, MontgomeryMultR1, NumberLength * sizeof(limb)))
{ // Power is one, so it is not a primitive root.
logMachineState = CALC_LOG_BASE;
// Find primitive root
primRoot[0].x = 1;
if (NumberLength > 1)
{
memset(&primRoot[1], 0, (NumberLength - 1) * sizeof(limb));
}
do
{
primRoot[0].x++;
modPow(primRoot, tmpBase.limbs, tmpBase.nbrLimbs, primRootPwr);
} while (!memcmp(primRootPwr, MontgomeryMultR1, NumberLength * sizeof(limb)));
}
else
{ // Power is not 1, so the base is a primitive root.
logMachineState = BASE_PRIMITIVE_ROOT;
memcpy(primRoot, baseMontg, NumberLength * sizeof(limb));
}
for (;;)
{ // Calculate discrete logarithm in subgroup.
runningExp.nbrLimbs = 1; // runningExp <- 0
runningExp.limbs[0].x = 0;
runningExp.sign = SIGN_POSITIVE;
powSubGroupOrder.nbrLimbs = 1; // powSubGroupOrder <- 1
powSubGroupOrder.limbs[0].x = 1;
powSubGroupOrder.sign = SIGN_POSITIVE;
CopyBigInt(¤tExp, &groupOrder);
if (logMachineState == BASE_PRIMITIVE_ROOT)
{
memcpy(basePHMontg, baseMontg, NumberLength * sizeof(limb));
memcpy(currPowerMontg, powerMontg, NumberLength * sizeof(limb));
}
else if (logMachineState == CALC_LOG_BASE)
{
memcpy(basePHMontg, primRoot, NumberLength * sizeof(limb));
memcpy(currPowerMontg, baseMontg, NumberLength * sizeof(limb));
}
else
{ // logMachineState == CALC_LOG_POWER
memcpy(primRoot, basePHMontg, NumberLength * sizeof(limb));
memcpy(currPowerMontg, powerMontg, NumberLength * sizeof(limb));
}
for (indexExp = 0; indexExp < astFactorsGO[indexBase + 1].multiplicity; indexExp++)
{
/* PH below comes from Pohlig-Hellman algorithm */
BigIntDivide(¤tExp, &subGroupOrder, ¤tExp);
modPow(currPowerMontg, currentExp.limbs, currentExp.nbrLimbs, powerPHMontg);
BigIntDivide(&baseExp, &subGroupOrder, &baseExp);
if (subGroupOrder.nbrLimbs == 1 && subGroupOrder.limbs[0].x < 20)
{ // subGroupOrder less than 20.
if (!ComputeDLogModSubGroupOrder(indexBase, indexExp, &Exponent, &subGroupOrder))
{
return;
}
}
else
{ // Use Pollard's rho method with Brent's modification
memcpy(nbrPower, powerPHMontg, NumberLength * sizeof(limb));
memcpy(nbrBase, primRootPwr, NumberLength * sizeof(limb));
memcpy(nbrR2, nbrBase, NumberLength * sizeof(limb));
memset(nbrA2, 0, NumberLength * sizeof(limb));
memset(nbrB2, 0, NumberLength * sizeof(limb));
nbrB2[0].x = 1;
addA2.x = addB2.x = 0;
mult2.x = 1;
brentR = 1;
brentK = 0;
EndPollardBrentRho = FALSE;
do
{
memcpy(nbrR, nbrR2, NumberLength * sizeof(limb));
memcpy(nbrA, nbrA2, NumberLength * sizeof(limb));
memcpy(nbrB, nbrB2, NumberLength * sizeof(limb));
addA = addA2;
addB = addB2;
mult1 = mult2;
brentR *= 2;
do
{
brentK++;
if (NumberLength == 1)
{
magnitude = (double)nbrR2[leastSignificantDword].x;
}
else
{
magnitude = (double)nbrR2[mostSignificantDword].x * LIMB_RANGE +
nbrR2[leastSignificantDword].x;
}
if (magnitude < firstLimit)
{
modmult(nbrR2, nbrPower, nbrROther);
addA2.x++;
}
else if (magnitude < secondLimit)
{
modmult(nbrR2, nbrR2, nbrROther);
mult2.x *= 2;
addA2.x *= 2;
addB2.x *= 2;
}
else
{
modmult(nbrR2, nbrBase, nbrROther);
addB2.x++;
}
// Exchange nbrR2 and nbrROther
memcpy(nbrTemp, nbrR2, NumberLength * sizeof(limb));
memcpy(nbrR2, nbrROther, NumberLength * sizeof(limb));
memcpy(nbrROther, nbrTemp, NumberLength * sizeof(limb));
if (addA2.x >= (int)(LIMB_RANGE / 2) || addB2.x >= (int)(LIMB_RANGE / 2) ||
mult2.x >= (int)(LIMB_RANGE / 2))
{
// nbrA2 <- (nbrA2 * mult2 + addA2) % subGroupOrder
AdjustExponent(nbrA2, mult2, addA2, &subGroupOrder);
// nbrB2 <- (nbrB2 * mult2 + addB2) % subGroupOrder
AdjustExponent(nbrB2, mult2, addB2, &subGroupOrder);
mult2.x = 1;
addA2.x = addB2.x = 0;
}
if (!memcmp(nbrR, nbrR2, NumberLength * sizeof(limb)))
{
EndPollardBrentRho = TRUE;
break;
}
} while (brentK < brentR);
} while (EndPollardBrentRho == FALSE);
ExchangeMods(); // TestNbr <- subGroupOrder
// nbrA <- (nbrA * mult1 + addA) % subGroupOrder
AdjustExponent(nbrA, mult1, addA, &subGroupOrder);
// nbrB <- (nbrB * mult1 + addB) % subGroupOrder
AdjustExponent(nbrB, mult1, addB, &subGroupOrder);
// nbrA2 <- (nbrA * mult2 + addA2) % subGroupOrder
AdjustExponent(nbrA2, mult2, addA2, &subGroupOrder);
// nbrB2 <- (nbrA * mult2 + addB2) % subGroupOrder
AdjustExponent(nbrB2, mult2, addB2, &subGroupOrder);
// nbrB <- (nbrB2 - nbrB) % subGroupOrder
SubtBigNbrMod(nbrB2, nbrB, nbrB);
SubtBigNbrMod(nbrA, nbrA2, nbrA);
if (BigNbrIsZero(nbrA))
{ // Denominator is zero, so rho does not work.
ExchangeMods(); // TestNbr <- modulus
if (!ComputeDLogModSubGroupOrder(indexBase, indexExp, &Exponent, &subGroupOrder))
{
return; // Cannot compute discrete logarithm.
}
}
else
{
// Exponent <- (nbrB / nbrA) (mod subGroupOrder)
UncompressLimbsBigInteger(nbrA, &bigNbrA);
UncompressLimbsBigInteger(nbrB, &bigNbrB);
BigIntModularDivisionSaveTestNbr(&bigNbrB, &bigNbrA, &subGroupOrder, &Exponent);
Exponent.sign = SIGN_POSITIVE;
ExchangeMods(); // TestNbr <- modulus
}
}
modPow(primRoot, Exponent.limbs, Exponent.nbrLimbs, tmpBase.limbs);
ModInvBigNbr(tmpBase.limbs, tmpBase.limbs, TestNbr, NumberLength);
modmult(tmpBase.limbs, currPowerMontg, currPowerMontg);
BigIntMultiply(&Exponent, &powSubGroupOrder, &tmpBase);
BigIntAdd(&runningExp, &tmpBase, &runningExp);
BigIntMultiply(&powSubGroupOrder, &subGroupOrder, &powSubGroupOrder);
modPow(primRoot, subGroupOrder.limbs, subGroupOrder.nbrLimbs, tmpBase.limbs);
memcpy(primRoot, tmpBase.limbs, NumberLength * sizeof(limb));
}
if (logMachineState == BASE_PRIMITIVE_ROOT)
{ // Discrete logarithm was determined for this subgroup.
ExponentsGOComputed[indexBase] = astFactorsGO[indexBase + 1].multiplicity;
break;
}
if (logMachineState == CALC_LOG_BASE)
{
CopyBigInt(&runningExpBase, &runningExp);
logMachineState = CALC_LOG_POWER;
}
else
{ // Set powSubGroupOrderBak to powSubGroupOrder.
// if runningExpBase is not multiple of subGroupOrder,
// discrete logarithm is runningExp/runningExpBase mod powSubGroupOrderBak.
// Otherwise if runningExp is multiple of subGroupOrder, there is no logarithm.
// Otherwise, divide runningExp, runnignExpBase and powSubGroupOrderBak by subGroupOrder and repeat.
ExponentsGOComputed[indexBase] = astFactorsGO[indexBase + 1].multiplicity;
CopyBigInt(&powSubGroupOrderBak, &powSubGroupOrder);
do
{
BigIntRemainder(&runningExpBase, &subGroupOrder, &tmpBase);
if (tmpBase.nbrLimbs > 1 || tmpBase.limbs[0].x != 0)
{ // runningExpBase is not multiple of subGroupOrder
BigIntModularDivisionSaveTestNbr(&runningExp, &runningExpBase, &powSubGroupOrderBak, &tmpBase);
CopyBigInt(&runningExp, &tmpBase);
break;
}
BigIntRemainder(&runningExp, &subGroupOrder, &tmpBase);
if (tmpBase.nbrLimbs > 1 || tmpBase.limbs[0].x != 0)
{ // runningExpBase is not multiple of subGroupOrder
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
BigIntDivide(&runningExp, &subGroupOrder, &tmpBase);
CopyBigInt(&runningExp, &tmpBase);
BigIntDivide(&runningExpBase, &subGroupOrder, &tmpBase);
CopyBigInt(&runningExpBase, &tmpBase);
BigIntDivide(&powSubGroupOrderBak, &subGroupOrder, &tmpBase);
CopyBigInt(&powSubGroupOrderBak, &tmpBase);
ExponentsGOComputed[indexBase]--;
if (tmpBase.nbrLimbs == 1 && tmpBase.limbs[0].x == 1)
{
break;
}
BigIntRemainder(&runningExpBase, &subGroupOrder, &tmpBase);
} while (tmpBase.nbrLimbs == 1 && tmpBase.limbs[0].x == 0);
CopyBigInt(&powSubGroupOrder, &powSubGroupOrderBak);
// The logarithm is runningExp / runningExpBase mod powSubGroupOrder
// When powSubGroupOrder is even, we cannot use Montgomery.
if (powSubGroupOrder.limbs[0].x & 1)
{ // powSubGroupOrder is odd.
BigIntModularDivisionSaveTestNbr(&runningExp, &runningExpBase, &powSubGroupOrder, &tmpBase);
CopyBigInt(&runningExp, &tmpBase);
}
else
{ // powSubGroupOrder is even (power of 2).
NumberLength = powSubGroupOrder.nbrLimbs;
CompressLimbsBigInteger(nbrB, &runningExpBase);
ComputeInversePower2(nbrB, nbrA, nbrB2); // nbrB2 is auxiliary var.
CompressLimbsBigInteger(nbrB, &runningExp);
multiply(nbrA, nbrB, nbrA, NumberLength, NULL); // nbrA <- quotient.
UncompressLimbsBigInteger(nbrA, &runningExp);
}
break;
}
}
CopyBigInt(&nbrV[indexBase], &runningExp);
NumberLength = powSubGroupOrder.nbrLimbs;
memcpy(TestNbr, powSubGroupOrder.limbs, NumberLength * sizeof(limb));
TestNbr[NumberLength].x = 0;
GetMontgomeryParms(NumberLength);
for (indexExp = 0; indexExp < indexBase; indexExp++)
{
// nbrV[indexBase] <- (nbrV[indexBase] - nbrV[indexExp])*
// modinv(PrimesGO[indexExp]^(ExponentsGO[indexExp]),
// powSubGroupOrder)
NumberLength = mod.nbrLimbs;
BigIntSubt(&nbrV[indexBase], &nbrV[indexExp], &nbrV[indexBase]);
BigIntRemainder(&nbrV[indexBase], &powSubGroupOrder, &nbrV[indexBase]);
if (nbrV[indexBase].sign == SIGN_NEGATIVE)
{
BigIntAdd(&nbrV[indexBase], &powSubGroupOrder, &nbrV[indexBase]);
}
pstFactors = &astFactorsGO[indexExp + 1];
UncompressBigInteger(pstFactors->ptrFactor, &tmpBase);
BigIntPowerIntExp(&tmpBase, ExponentsGOComputed[indexExp], &tmpBase);
BigIntRemainder(&tmpBase, &powSubGroupOrder, &tmpBase);
NumberLength = powSubGroupOrder.nbrLimbs;
CompressLimbsBigInteger(tmp2.limbs, &tmpBase);
modmult(tmp2.limbs, MontgomeryMultR2, tmp2.limbs);
if (NumberLength > 1 || TestNbr[0].x != 1)
{ // If TestNbr != 1 ...
ModInvBigNbr(tmp2.limbs, tmp2.limbs, TestNbr, NumberLength);
}
tmpBase.limbs[0].x = 1;
memset(&tmpBase.limbs[1], 0, (NumberLength - 1) * sizeof(limb));
modmult(tmpBase.limbs, tmp2.limbs, tmp2.limbs);
UncompressLimbsBigInteger(tmp2.limbs, &tmpBase);
BigIntMultiply(&tmpBase, &nbrV[indexBase], &nbrV[indexBase]);
}
BigIntRemainder(&nbrV[indexBase], &powSubGroupOrder, &nbrV[indexBase]);
BigIntMultiply(&nbrV[indexBase], &logarMult, &tmpBase);
BigIntAdd(&logar, &tmpBase, &logar);
BigIntMultiply(&logarMult, &powSubGroupOrder, &logarMult);
}
multiplicity = astFactorsMod[index].multiplicity;
UncompressBigInteger(ptrPrime, &bigNbrB);
expon = 1;
if (bigNbrB.nbrLimbs == 1 && bigNbrB.limbs[0].x == 2)
{ // Prime factor is 2. Base and power are odd at this moment.
int lsbBase = base.limbs[0].x;
int lsbPower = power.limbs[0].x;
if (multiplicity > 1)
{
int mask = (multiplicity == 2? 3 : 7);
expon = (multiplicity == 2 ? 2 : 3);
if ((lsbPower & mask) == 1)
{
intToBigInteger(&logar, 0);
intToBigInteger(&logarMult, (lsbBase == 1 ? 1 : 2));
}
else if (((lsbPower - lsbBase) & mask) == 0)
{
intToBigInteger(&logar, 1);
intToBigInteger(&logarMult, 2);
}
else
{
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
}
}
for (; expon < multiplicity; expon++)
{ // Repeated factor.
// L = logar, LM = logarMult
// B = base, P = power, p = prime
// B^n = P (mod p^(k+1)) -> n = L + m*LM m = ?
// B^(L + m*LM) = P
// (B^LM) ^ m = P*B^(-L)
// B^LM = r*p^k + 1, P*B^(-L) = s*p^k + 1
// (r*p^k + 1)^m = s*p^k + 1
// From binomial theorem: m = s / r (mod p)
// If r = 0 and s != 0 there is no solution.
// If r = 0 and s = 0 do not change LM.
BigIntPowerIntExp(&bigNbrB, expon + 1, &bigNbrA);
NumberLength = bigNbrA.nbrLimbs;
memcpy(TestNbr, bigNbrA.limbs, NumberLength * sizeof(limb));
GetMontgomeryParms(NumberLength);
BigIntRemainder(&base, &bigNbrA, &tmpBase);
CompressLimbsBigInteger(baseMontg, &tmpBase);
modmult(baseMontg, MontgomeryMultR2, baseMontg);
modPow(baseMontg, logarMult.limbs, logarMult.nbrLimbs, primRootPwr); // B^LM
tmpBase.limbs[0].x = 1; // Convert from Montgomery to standard notation.
memset(&tmpBase.limbs[1], 0, (NumberLength - 1) * sizeof(limb));
modmult(primRootPwr, tmpBase.limbs, primRootPwr); // B^LM
ModInvBigNbr(baseMontg, tmpBase.limbs, TestNbr, NumberLength); // B^(-1)
modPow(tmpBase.limbs, logar.limbs, logar.nbrLimbs, primRoot); // B^(-L)
BigIntRemainder(&power, &bigNbrA, &tmpBase);
CompressLimbsBigInteger(tmp2.limbs, &tmpBase);
modmult(primRoot, tmp2.limbs, primRoot); // P*B^(-L)
BigIntDivide(&bigNbrA, &bigNbrB, &tmpBase);
UncompressLimbsBigInteger(primRootPwr, &tmp2);
BigIntDivide(&tmp2, &tmpBase, &bigNbrA); // s
UncompressLimbsBigInteger(primRoot, &baseModGO); // Use baseMontGO as temp var.
BigIntDivide(&baseModGO, &tmpBase, &tmp2); // r
if (bigNbrA.nbrLimbs == 1 && bigNbrA.limbs[0].x == 0)
{ // r equals zero.
if (tmp2.nbrLimbs != 1 || tmp2.limbs[0].x != 0)
{ // s does not equal zero.
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
}
else
{ // r does not equal zero.
BigIntModularDivisionSaveTestNbr(&tmp2, &bigNbrA, &bigNbrB, &tmpBase); // m
BigIntMultiply(&tmpBase, &logarMult, &tmp2);
BigIntAdd(&logar, &tmp2, &logar);
BigIntMultiply(&logarMult, &bigNbrB, &logarMult);
}
}
// Based on logar and logarMult, compute DiscreteLog and DiscreteLogPeriod
// using the following formulas, that can be deduced from the Chinese
// Remainder Theorem:
// L = logar, LM = logarMult, DL = DiscreteLog, DLP = DiscreteLogPeriod.
// The modular implementation does not allow operating with even moduli.
//
// g <- gcd(LM, DLP)
// if (L%g != DL%g) there is no discrete logarithm, so go out.
// h <- LM / g
// if h is odd:
// t <- (L - DL) / DLP (mod h)
// t <- DLP * t + DL
// else
// i <- DLP / g
// t <- (DL - L) / LM (mod i)
// t <- LM * t + L
// endif
// DLP <- DLP * h
// DL <- t % DLP
BigIntGcd(&logarMult, &DiscreteLogPeriod, &tmpBase);
BigIntRemainder(&logar, &tmpBase, &bigNbrA);
BigIntRemainder(&DiscreteLog, &tmpBase, &bigNbrB);
if (!TestBigNbrEqual(&bigNbrA, &bigNbrB))
{
showText("There is no discrete logarithm");
DiscreteLogPeriod.sign = SIGN_NEGATIVE;
return;
}
BigIntDivide(&logarMult, &tmpBase, &tmp2);
if (tmp2.limbs[0].x & 1)
{ // h is odd.
BigIntSubt(&logar, &DiscreteLog, &tmpBase);
BigIntModularDivisionSaveTestNbr(&tmpBase, &DiscreteLogPeriod, &tmp2, &bigNbrA);
BigIntMultiply(&DiscreteLogPeriod, &bigNbrA, &tmpBase);
BigIntAdd(&tmpBase, &DiscreteLog, &tmpBase);
}
else
{ // h is even.
BigIntDivide(&DiscreteLogPeriod, &tmpBase, &bigNbrB);
BigIntSubt(&DiscreteLog, &logar, &tmpBase);
BigIntModularDivisionSaveTestNbr(&tmpBase, &logarMult, &bigNbrB, &bigNbrA);
BigIntMultiply(&logarMult, &bigNbrA, &tmpBase);
BigIntAdd(&tmpBase, &logar, &tmpBase);
}
BigIntMultiply(&DiscreteLogPeriod, &tmp2, &DiscreteLogPeriod);
BigIntRemainder(&tmpBase, &DiscreteLogPeriod, &DiscreteLog);
}
#if 0
textExp.setText(DiscreteLog.toString());
textPeriod.setText(DiscreteLogPeriod.toString());
long t = OldTimeElapsed / 1000;
labelStatus.setText("Time elapsed: " +
t / 86400 + "d " + (t % 86400) / 3600 + "h " + ((t % 3600) / 60) + "m " + (t % 60) +
"s mod mult: " + lModularMult);
#endif
}
OutputItemHeaderWidget::OutputItemHeaderWidget(OutputItemContentWidget *output, QWidget *parent) :
QFrame(parent),
_maximized(false)
{
setContentsMargins(5,0,0,0);
// Maximize button
_maxButton = new QPushButton;
_maxButton->setIcon(GuiRegistry::instance().maximizeIcon());
_maxButton->setToolTip("Maximize or restore back this output result. You also can double-click on result's header.");
_maxButton->setFixedSize(18, 18);
_maxButton->setFlat(true);
VERIFY(connect(_maxButton, SIGNAL(clicked()), this, SLOT(maximizePart())));
// Text mode button
_textButton = new QPushButton(this);
_textButton->setIcon(GuiRegistry::instance().textIcon());
_textButton->setToolTip("View results in text mode");
_textButton->setFixedSize(24, 24);
_textButton->setFlat(true);
_textButton->setCheckable(true);
// Tree mode button
_treeButton = new QPushButton(this);
_treeButton->hide();
_treeButton->setIcon(GuiRegistry::instance().treeIcon());
_treeButton->setToolTip("View results in tree mode");
_treeButton->setFixedSize(24, 24);
_treeButton->setFlat(true);
_treeButton->setCheckable(true);
_treeButton->setChecked(true);
// Table mode button
_tableButton = new QPushButton(this);
_tableButton->hide();
_tableButton->setIcon(GuiRegistry::instance().tableIcon());
_tableButton->setToolTip("View results in table mode");
_tableButton->setFixedSize(24, 24);
_tableButton->setFlat(true);
_tableButton->setCheckable(true);
_tableButton->setChecked(true);
// Custom mode button
_customButton = new QPushButton(this);
_customButton->hide();
_customButton->setIcon(GuiRegistry::instance().customIcon());
_customButton->setToolTip("View results in custom UI");
_customButton->setFixedSize(24, 24);
_customButton->setFlat(true);
_customButton->setCheckable(true);
VERIFY(connect(_textButton, SIGNAL(clicked()), output, SLOT(showText())));
VERIFY(connect(_treeButton, SIGNAL(clicked()), output, SLOT(showTree())));
VERIFY(connect(_tableButton, SIGNAL(clicked()), output, SLOT(showTable())));
VERIFY(connect(_customButton, SIGNAL(clicked()), output, SLOT(showCustom())));
_collectionIndicator = new Indicator(GuiRegistry::instance().collectionIcon());
_timeIndicator = new Indicator(GuiRegistry::instance().timeIcon());
_paging = new PagingWidget();
_collectionIndicator->hide();
_timeIndicator->hide();
_paging->hide();
QHBoxLayout *layout = new QHBoxLayout();
layout->setContentsMargins(2, 0, 5, 1);
layout->setSpacing(0);
layout->addWidget(_collectionIndicator);
layout->addWidget(_timeIndicator);
QSpacerItem *hSpacer = new QSpacerItem(2000, 24, QSizePolicy::Preferred, QSizePolicy::Minimum);
layout->addSpacerItem(hSpacer);
layout->addWidget(_paging);
layout->addWidget(createVerticalLine());
layout->addSpacing(2);
if (output->isCustomModeSupported()) {
layout->addWidget(_customButton, 0, Qt::AlignRight);
_customButton->show();
}
if (output->isTreeModeSupported()) {
layout->addWidget(_treeButton, 0, Qt::AlignRight);
_treeButton->show();
}
if (output->isTableModeSupported()) {
layout->addWidget(_tableButton, 0, Qt::AlignRight);
_tableButton->show();
}
if (output->isTextModeSupported())
layout->addWidget(_textButton, 0, Qt::AlignRight);
layout->addSpacing(3);
layout->addWidget(createVerticalLine());
layout->addWidget(_maxButton, 0, Qt::AlignRight);
setLayout(layout);
}
void initEvent()
{
vl::Log::notify(appletInfo());
showSimplePipe();
showText();
}
OutputItemHeaderWidget::OutputItemHeaderWidget(
OutputItemContentWidget *outputItemContentWidget, bool multipleResults,
bool tabbedResults, bool firstItem, bool lastItem, QWidget *parent) :
QFrame(parent),
_maxButton(nullptr), _dockUndockButton(nullptr), _maximized(false),
_multipleResults(multipleResults),
_firstItem(firstItem), _lastItem(lastItem), _orientation(Qt::Vertical)
{
setContentsMargins(5, 0, 0, 0);
auto const* outputWidget = qobject_cast<OutputWidget*>(outputItemContentWidget->parentWidget());
_orientation = outputWidget->getOrientation();
// Text mode button
_textButton = new QPushButton(this);
_textButton->setIcon(GuiRegistry::instance().textIcon());
_textButton->setToolTip("View results in text mode");
_textButton->setFixedSize(24, 24);
_textButton->setFlat(true);
_textButton->setCheckable(true);
// Tree mode button
_treeButton = new QPushButton(this);
_treeButton->hide();
_treeButton->setIcon(GuiRegistry::instance().treeIcon());
_treeButton->setToolTip("View results in tree mode");
_treeButton->setFixedSize(24, 24);
_treeButton->setFlat(true);
_treeButton->setCheckable(true);
_treeButton->setChecked(true);
// Table mode button
_tableButton = new QPushButton(this);
_tableButton->hide();
_tableButton->setIcon(GuiRegistry::instance().tableIcon());
_tableButton->setToolTip("View results in table mode");
_tableButton->setFixedSize(24, 24);
_tableButton->setFlat(true);
_tableButton->setCheckable(true);
_tableButton->setChecked(true);
// Custom mode button
_customButton = new QPushButton(this);
_customButton->hide();
_customButton->setIcon(GuiRegistry::instance().customIcon());
_customButton->setToolTip("View results in custom UI");
_customButton->setFixedSize(24, 24);
_customButton->setFlat(true);
_customButton->setCheckable(true);
// Create maximize button only if there are multiple results
if (_multipleResults && !tabbedResults) {
_maxButton = new QPushButton;
_maxButton->setIcon(GuiRegistry::instance().maximizeIcon());
_maxButton->setToolTip("Maximize this output result (double-click on result's header)");
_maxButton->setFixedSize(18, 18);
_maxButton->setFlat(true);
VERIFY(connect(_maxButton, SIGNAL(clicked()), this, SLOT(maximizeMinimizePart())));
}
auto dockWidget = qobject_cast<QueryWidget::CustomDockWidget*>(outputItemContentWidget->parentWidget()->parentWidget());
auto queryWidget = dockWidget->getParentQueryWidget();
_dockUndockButton = new QPushButton;
_dockUndockButton->setFixedSize(18, 18);
_dockUndockButton->setFlat(true);
_dockUndockButton->setHidden(true);
applyDockUndockSettings(!dockWidget->isFloating());
VERIFY(connect(_dockUndockButton, SIGNAL(clicked()), queryWidget, SLOT(dockUndock())));
VERIFY(connect(_textButton, SIGNAL(clicked()), outputItemContentWidget, SLOT(showText())));
VERIFY(connect(_treeButton, SIGNAL(clicked()), outputItemContentWidget, SLOT(showTree())));
VERIFY(connect(_tableButton, SIGNAL(clicked()), outputItemContentWidget, SLOT(showTable())));
VERIFY(connect(_customButton, SIGNAL(clicked()), outputItemContentWidget, SLOT(showCustom())));
_collectionIndicator = new Indicator(GuiRegistry::instance().collectionIcon());
_timeIndicator = new Indicator(GuiRegistry::instance().timeIcon());
_paging = new PagingWidget();
_collectionIndicator->hide();
_timeIndicator->hide();
_paging->hide();
QHBoxLayout *layout = new QHBoxLayout();
#ifdef __APPLE__
layout->setContentsMargins(2, 8, 5, 1);
#else
layout->setContentsMargins(2, 0, 5, 1);
#endif
layout->setSpacing(0);
layout->addWidget(_collectionIndicator);
layout->addWidget(_timeIndicator);
QSpacerItem *hSpacer = new QSpacerItem(2000, 24, QSizePolicy::Preferred, QSizePolicy::Minimum);
layout->addSpacerItem(hSpacer);
layout->addWidget(_paging);
layout->addWidget(createVerticalLine());
layout->addSpacing(2);
if (outputItemContentWidget->isCustomModeSupported()) {
layout->addWidget(_customButton, 0, Qt::AlignRight);
_customButton->show();
}
if (outputItemContentWidget->isTreeModeSupported()) {
layout->addWidget(_treeButton, 0, Qt::AlignRight);
_treeButton->show();
}
if (outputItemContentWidget->isTableModeSupported()) {
layout->addWidget(_tableButton, 0, Qt::AlignRight);
_tableButton->show();
}
if (outputItemContentWidget->isTextModeSupported())
layout->addWidget(_textButton, 0, Qt::AlignRight);
if (_multipleResults)
layout->addWidget(_maxButton, 0, Qt::AlignRight);
layout->addSpacing(3);
_verticalLine = createVerticalLine();
_verticalLine->setHidden(true);
layout->addWidget(_verticalLine);
layout->addWidget(_dockUndockButton);
setLayout(layout);
// Update dock/undock button visibility
if (_multipleResults)
updateDockButtonOnToggleOrientation();
else {
_verticalLine->setVisible(true);
_dockUndockButton->setVisible(true);
}
if(tabbedResults)
setStyleSheet("background-color: white");
}
/*
* Code39 vectorization, implements Barcode1dBase::vectorize()
*/
void BarcodeCode39::vectorize( const std::string& codedData,
const std::string& displayText,
const std::string& cookedData,
double& w,
double& h )
{
/* determine width and establish horizontal scale, based on original cooked data */
double dataSize = cookedData.size();
double minL;
if ( !checksum() )
{
minL = (dataSize + 2)*(3*N + 6)*MIN_X + (dataSize + 1)*MIN_I;
}
else
{
minL = (dataSize + 3)*(3*N + 6)*MIN_X + (dataSize + 2)*MIN_I;
}
double scale;
if ( w == 0 )
{
scale = 1.0;
}
else
{
scale = w / (minL + 2*MIN_QUIET);
if ( scale < 1.0 )
{
scale = 1.0;
}
}
double width = minL * scale;
/* determine text parameters */
double hTextArea = scale * MIN_TEXT_AREA_HEIGHT;
double textSize = scale * MIN_TEXT_SIZE;
/* determine height of barcode */
double height = showText() ? h - hTextArea : h;
height = std::max( height, std::max( 0.15*width, MIN_HEIGHT ) );
/* determine horizontal quiet zone */
double xQuiet = std::max( (10 * scale * MIN_X), MIN_QUIET );
/* Now traverse the code string and draw each bar */
double x1 = xQuiet;
for ( unsigned int i=0; i < codedData.size(); i++ )
{
double lwidth;
switch ( codedData[i] )
{
case 'i':
/* Inter-character gap */
x1 += scale * MIN_I;
break;
case 'N':
/* Narrow bar */
lwidth = scale*MIN_X;
addLine( x1, 0.0, lwidth, height );
x1 += scale * MIN_X;
break;
case 'W':
/* Wide bar */
lwidth = scale*N*MIN_X;
addLine( x1, 0.0, lwidth, height );
x1 += scale * N * MIN_X;
break;
case 'n':
/* Narrow space */
x1 += scale * MIN_X;
break;
case 'w':
/* Wide space */
x1 += scale * N * MIN_X;
break;
default:
// NOT REACHED
break;
}
}
if ( showText() )
{
std::string starredText = "*" + displayText + "*";
addText( xQuiet + width/2, height + (hTextArea+0.7*textSize)/2, textSize, starredText );
}
/* Overwrite requested size with actual size. */
w = width + 2*xQuiet;
h = showText() ? height + hTextArea : height;
}
