int main() { char playAgain; do { nodes_expanded = 0; //initialize the board. char *board = newBoard(); //get player and computer characters. char playerPiece = askUser("\nPlease choose your character (x or o): ", X, O); char computerPiece = getOpponentPiece(playerPiece); //check if player wants to play first. char ch = askUser("\nDo you want to play first ? (y or n): ", 'y', 'n'); if(ch == 'y') { makePlayerMove(board, playerPiece); } else if(ch == 'n') { } char winner; int turn = COMPUTER; //game loop. while(!isFilled(board) && (winner = whoWon(board)) == NONE) { if(turn == COMPUTER) { makeComputerMove(board, computerPiece); turn = PLAYER; } else { makePlayerMove(board, playerPiece); turn = COMPUTER; } } printBoard(board); //print results. if(winner == playerPiece) { printf("\n$ Congratulations! you have won. $\n"); } else if(winner == NONE) { printf("\n* The game is a draw. *\n"); } else { printf("\n@ You Lose!! @\n"); } printf("\nNumber of nodes expanded: %d", nodes_expanded); //ask if user wants to play again. playAgain = askUser("\n Do you want to play again? (y or n): ", 'y', 'n'); }while(playAgain == 'y'); return 0; }
void displayMenu() { char choice; system("cls"); printf("[1]-DISPLAY ALL\n[a]-NEXT\n[d]-PREVIOUS\n"); printf("PRESS ESC TO RETURN TO MAIN MENU...\n"); choice=getch(); switch(choice) { case '1': displayArray(); getch(); displayMenu(); break; case 'a': nextItem(); getch(); displayMenu(); break; case 'd': prevItem(); getch(); displayMenu(); break; default: askUser(); break; } }
void PerformCopyTask::askForOverwrite(const QString &text, volatile bool &tryAgain, const volatile Flags &aborted) { qint32 answer = askUser( tr("Extracting..."), text, QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::No | QMessageBox::NoToAll | QMessageBox::Cancel, aborted); switch (answer) { case QMessageBox::Yes: tryAgain = true; break; case QMessageBox::YesToAll: m_overwriteAll = tryAgain = true; break; case QMessageBox::No: tryAgain = false; break; case QMessageBox::NoToAll: m_overwriteAll = tryAgain = false; break; case QMessageBox::Cancel: cancel(); break; } }
// dispatcher code for entering one of the available states void PlanExecutor::enterAvailableState() { if(mState == NOT_AVAILABLE) { mShowFilesAction->setEnabled(true); mRunBackupAction->setEnabled(true); mActionMenu->setEnabled(true); mState = WAITING_FOR_FIRST_BACKUP; //initial child state of "Available" state emit stateChanged(); } bool lShouldBeTakenNow = false; bool lShouldBeTakenLater = false; int lTimeUntilNextWakeup; QString lUserQuestion; QDateTime lNow = QDateTime::currentDateTime().toUTC(); switch(mPlan->mScheduleType) { case BackupPlan::MANUAL: break; case BackupPlan::INTERVAL: { QDateTime lNextTime = mPlan->nextScheduledTime(); if(!lNextTime.isValid() || lNextTime < lNow) { lShouldBeTakenNow = true; if(!mPlan->mLastCompleteBackup.isValid()) lUserQuestion = i18nc("@info", "Do you want to take a first backup now?"); else { QString t = KGlobal::locale()->prettyFormatDuration(mPlan->mLastCompleteBackup.secsTo(lNow) * 1000); lUserQuestion = i18nc("@info", "It's been %1 since the last backup was taken, " "do you want to take a backup now?", t); } } else { lShouldBeTakenLater = true; lTimeUntilNextWakeup = lNow.secsTo(lNextTime)*1000; } break; } case BackupPlan::USAGE: if(!mPlan->mLastCompleteBackup.isValid()) { lShouldBeTakenNow = true; lUserQuestion = i18nc("@info", "Do you want to take a first backup now?"); } else if(mPlan->mAccumulatedUsageTime > (quint32)mPlan->mUsageLimit * 3600) { lShouldBeTakenNow = true; QString t = KGlobal::locale()->prettyFormatDuration(mPlan->mAccumulatedUsageTime * 1000); lUserQuestion = i18nc("@info", "You've been active with this computer for %1 since the last backup was taken, " "do you want to take a backup now?", t); } break; } if(lShouldBeTakenNow) { // only ask the first time after destination has become available if(mPlan->mAskBeforeTakingBackup && mState == WAITING_FOR_FIRST_BACKUP) { askUser(lUserQuestion); } else { enterBackupRunningState(); } } else if(lShouldBeTakenLater){ // schedule a wakeup for asking again when the time is right. mSchedulingTimer->start(lTimeUntilNextWakeup); } }
// dispatcher code for entering one of the available states void PlanExecutor::enterAvailableState() { if(mState == NOT_AVAILABLE) { mState = WAITING_FOR_FIRST_BACKUP; //initial child state of "Available" state emit stateChanged(); } bool lShouldBeTakenNow = false; bool lShouldBeTakenLater = false; int lTimeUntilNextWakeup; QString lUserQuestion; QDateTime lNow = QDateTime::currentDateTime().toUTC(); switch(mPlan->mScheduleType) { case BackupPlan::MANUAL: break; case BackupPlan::INTERVAL: { QDateTime lNextTime = mPlan->nextScheduledTime(); if(!lNextTime.isValid() || lNextTime < lNow) { lShouldBeTakenNow = true; if(!mPlan->mLastCompleteBackup.isValid()) lUserQuestion = xi18nc("@info", "Do you want to save a first backup now?"); else { QString t = KFormat().formatSpelloutDuration(mPlan->mLastCompleteBackup.secsTo(lNow) * 1000); lUserQuestion = xi18nc("@info", "It has been %1 since last backup was saved.\n" "Save a new backup now?", t); } } else { lShouldBeTakenLater = true; lTimeUntilNextWakeup = lNow.secsTo(lNextTime)*1000; } break; } case BackupPlan::USAGE: if(!mPlan->mLastCompleteBackup.isValid()) { lShouldBeTakenNow = true; lUserQuestion = xi18nc("@info", "Do you want to save a first backup now?"); } else if(mPlan->mAccumulatedUsageTime > (quint32)mPlan->mUsageLimit * 3600) { lShouldBeTakenNow = true; QString t = KFormat().formatSpelloutDuration(mPlan->mAccumulatedUsageTime * 1000); lUserQuestion = xi18nc("@info", "You have been active for %1 since last backup was saved.\n" "Save a new backup now?", t); } break; } if(lShouldBeTakenNow) { // Only ask the first time after destination has become available. // Always ask if power saving is active. if( (mPlan->mAskBeforeTakingBackup && mState == WAITING_FOR_FIRST_BACKUP) || powerSaveActive()) { askUser(lUserQuestion); } else { startBackupSaveJob(); } } else if(lShouldBeTakenLater){ // schedule a wakeup for asking again when the time is right. mSchedulingTimer->start(lTimeUntilNextWakeup); } }
/** Read a transaction from the stream, parse it and ask the user * if they approve it. * \param out_approved A non-zero value will be written to here if the * user approved the transaction, otherwise a zero value * will be written. * \param sig_hash The signature hash of the transaction will be written to * here by parseTransaction(). This must be an array of 32 * bytes. * \param transaction_length The length of the transaction, in number of * bytes. This can be derived from the payload * length of a packet. */ static NOINLINE void parseTransactionAndAsk(uint8_t *out_approved, uint8_t *sig_hash, uint32_t transaction_length) { TransactionErrors r; uint8_t transaction_hash[32]; // Validate transaction and calculate hashes of it. *out_approved = 0; clearOutputsSeen(); r = parseTransaction(sig_hash, transaction_hash, transaction_length); if (r != TRANSACTION_NO_ERROR) { // Transaction parse error. writeString(STRINGSET_TRANSACTION, (uint8_t)r, PACKET_TYPE_FAILURE); return; } // Get permission from user. *out_approved = 0; // Does transaction_hash match previous approved transaction? if (prev_transaction_hash_valid) { if (bigCompare(transaction_hash, prev_transaction_hash) == BIGCMP_EQUAL) { *out_approved = 1; prev_transaction_hash_valid--; } } if (!(*out_approved)) { // Need to explicitly get permission from user. // The call to parseTransaction() should have logged all the outputs // to the user interface. if (askUser(ASKUSER_SIGN_TRANSACTION)) { writeString(STRINGSET_MISC, MISCSTR_PERMISSION_DENIED, PACKET_TYPE_FAILURE); } else { // User approved transaction. *out_approved = 1; memcpy(prev_transaction_hash, transaction_hash, 32); // The transaction hash can only be reused another // (number of inputs) - 1 times. This is to prevent an exploit // where an attacker crafts a lot of copies (with differing inputs // but identical outputs) of a genuine transaction. With unlimited // reuse of the transaction hash, acceptance of the original // genuine transaction would also allow all the copies to be // automatically accepted, causing the user to spend more than // they intended. prev_transaction_hash_valid = getTransactionNumInputs(); if (prev_transaction_hash_valid) { prev_transaction_hash_valid--; } } } // if (!(*out_approved)) }
int validateUser() { int length = 50; char login[length * 2 + 2]; askUser("User: "******":"); askUser("Password: "******"TEST: %s CORRECT: %s RES: %d\n", login, passwords[i], result); if(result == 0) return 1; } return 0; }
// creates new file void WMain::newfile() { if(cDocument->filechanged) { int userAnswer = askUser(tr("File has been changed. Save?")); if(userAnswer == 2) saveFileAction(); else if(userAnswer == 1) return; } delete cDocument; cDocument = new CDocument; updateList(); updateStatusbar(); }
// opens file void WMain::openfile(QString filename) { if(cDocument->filechanged) { int userAnswer = askUser(tr("File has been changed. Save?")); if(userAnswer == 2) { saveFileAction(); openFileAction(filename); } else if(userAnswer == 1) return; else openFileAction(filename); } else openFileAction(filename); }
void askUser() { char choice; int x; int loop; system("cls"); printf("---MAIN MENU---\n"); printf("\n[1]-ENTER STRING\n[2]-DISPLAY\n[3]-SORT\n\n"); choice=getch(); switch(choice) { case '1': printf("How many number(s)?"); scanf("%d",&loop); for(x=0;x<loop;x++) askStr(); getch(); askUser(); break; case '2': displayMenu(); getch(); askUser(); break; case '3': sortMenu(); getch(); askUser(); break; default: getch(); break; } }
// window close event void WMain::closeEvent(QCloseEvent * e) { if(cDocument->filechanged) { int userAnswer = askUser(tr("File has been changed. Save?")); if (userAnswer == 2) { saveFileAction(); application->quit(); e->accept(); } else if(userAnswer == 1) e->ignore(); else if(userAnswer == 0) { e->accept(); application->quit(); } else e->ignore(); return; } else application->quit(); }
bool UnPackIntoSubdirActionTask::askForSkipIfNotCopy(const QString &error, bool &flag, const volatile Flags &aborted) { qint32 answer = askUser( tr("Extracting..."), QString(error).append(L'\n').append(tr("Skip it?")), QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::Retry | QMessageBox::Cancel, aborted); if (answer == QMessageBox::YesToAll) flag = true; else if (answer == QMessageBox::Retry) return true; else if (answer == QMessageBox::Cancel) cancel(); return false; }
void PerformCopyTask::askForSkipIfNotCopy(const QString &text, volatile bool &tryAgain, const volatile Flags &aborted) { qint32 answer = askUser( tr("Extracting..."), text, QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::Retry | QMessageBox::Cancel, aborted); if (answer == QMessageBox::YesToAll) m_skipAllIfNotCopy = true; else if (answer == QMessageBox::Retry) tryAgain = true; else if (answer == QMessageBox::Cancel) cancel(); }
bool testPasswordStrength(std::string &rPassword, mySafeCore::ImySafeCore * pMySafeCore, std::istream &rInput, std::ostream &rOutput, CCommandParser const &rCommandParser) { bool IsPasswordStrong = false; int Strength = pMySafeCore->getPasswordStrength(rPassword, ""); if (Strength < 75) { IsPasswordStrong = false; rOutput << "[WARNING] Password strength is: " << getStrengthString(Strength).c_str() << " (" << Strength << "%)" << std::endl; if (rCommandParser.isNotInteractive()) { throw ExInputError("Used password is too weak in not-interactive mode. Please specify a stronger password.", 1); } if (askUser(rInput, rOutput, rCommandParser, std::string("Do you want to chose another password?")) == true) { rPassword = ""; } else { IsPasswordStrong = true; } } else { IsPasswordStrong = true; if (!rCommandParser.isSilent()) { rOutput << "Password strength is: " << getStrengthString(Strength).c_str() << std::endl; } } return IsPasswordStrong; }
void askUser() { int num; int x=10; int i; char choices; struct node *current; current=head; system("cls"); printf("\n[1]-ENQUEUE\n[2]-DEQUEUE\n[3]-FRONT\n[4]-REAR\n"); choices=getch(); switch(choices) { case '1': num=askNum(); for(i=0;i<num;i++) { while(x<0||x>9) { printf("Enter number: "); scanf("%d",&x); } insertRear(x); x=10; displayArray(); } getch(); askUser(); break; case '2': deleteFront(); displayArray(); getch(); askUser(); break; case '3': if(head!=NULL) { printf("%d",head->data); } else { printf("List is empty"); } getch(); askUser(); break; case '4': while(current->next!=NULL) { current=current->next; } printf("%d",current->data); getch(); askUser(); break; default: getch(); break; } }
void main() { head=NULL; askUser(); }
// cancels test void WMain::canceltest() { int userAnswer = askUser(tr("Are you sure to cancel test?")); if(userAnswer == 2) endTest(false); else if(userAnswer == 1) return; else return; }
/** Get packet from stream and deal with it. This basically implements the * protocol described in the file PROTOCOL. * * This function will always completely * read a packet before sending a response packet. As long as the host * does the same thing, deadlocks cannot occur. Thus a productive * communication session between the hardware Bitcoin wallet and a host * should consist of the wallet and host alternating between sending a * packet and receiving a packet. */ void processPacket(void) { uint8_t command; // Technically, the length of buffer should also be >= 4, since it is used // in a couple of places to obtain 32 bit values. This is guaranteed by // the reference to WALLET_ENCRYPTION_KEY_LENGTH, since no-one in their // right mind would use encryption with smaller than 32 bit keys. uint8_t buffer[MAX(NAME_LENGTH, WALLET_ENCRYPTION_KEY_LENGTH)]; uint32_t num_addresses; AddressHandle ah; WalletErrors wallet_return; command = streamGetOneByte(); getBytesFromStream(buffer, 4); payload_length = readU32LittleEndian(buffer); // Checklist for each case: // 1. Have you checked or dealt with length? // 2. Have you fully read the input stream before writing (to avoid // deadlocks)? // 3. Have you asked permission from the user (for potentially dangerous // operations)? // 4. Have you checked for errors from wallet functions? // 5. Have you used the right check for the wallet functions? switch (command) { case PACKET_TYPE_PING: // Ping request. // Just throw away the data and then send response. readAndIgnoreInput(); writeString(STRINGSET_MISC, MISCSTR_VERSION, PACKET_TYPE_PING_REPLY); break; // Commands PACKET_TYPE_PING_REPLY, PACKET_TYPE_SUCCESS and // PACKET_TYPE_FAILURE should never be received; they are only sent. case PACKET_TYPE_NEW_WALLET: // Create new wallet. if (!expectLength(WALLET_ENCRYPTION_KEY_LENGTH + NAME_LENGTH)) { getBytesFromStream(buffer, WALLET_ENCRYPTION_KEY_LENGTH); setEncryptionKey(buffer); getBytesFromStream(buffer, NAME_LENGTH); if (askUser(ASKUSER_NUKE_WALLET)) { writeString(STRINGSET_MISC, MISCSTR_PERMISSION_DENIED, PACKET_TYPE_FAILURE); } else { wallet_return = newWallet(buffer); translateWalletError(wallet_return, 0, NULL); } } break; case PACKET_TYPE_NEW_ADDRESS: // Create new address in wallet. if (!expectLength(0)) { if (askUser(ASKUSER_NEW_ADDRESS)) { writeString(STRINGSET_MISC, MISCSTR_PERMISSION_DENIED, PACKET_TYPE_FAILURE); } else { getAndSendAddressAndPublicKey(1); } } break; case PACKET_TYPE_GET_NUM_ADDRESSES: // Get number of addresses in wallet. if (!expectLength(0)) { num_addresses = getNumAddresses(); writeU32LittleEndian(buffer, num_addresses); wallet_return = walletGetLastError(); translateWalletError(wallet_return, 4, buffer); } break; case PACKET_TYPE_GET_ADDRESS_PUBKEY: // Get address and public key corresponding to an address handle. if (!expectLength(4)) { getAndSendAddressAndPublicKey(0); } break; case PACKET_TYPE_SIGN_TRANSACTION: // Sign a transaction. if (payload_length <= 4) { readAndIgnoreInput(); writeString(STRINGSET_MISC, MISCSTR_INVALID_PACKET, PACKET_TYPE_FAILURE); } else { getBytesFromStream(buffer, 4); ah = readU32LittleEndian(buffer); // Don't need to subtract 4 off payload_length because // getBytesFromStream() has already done so. validateAndSignTransaction(ah, payload_length); payload_length = 0; } break; case PACKET_TYPE_LOAD_WALLET: // Load wallet. if (!expectLength(WALLET_ENCRYPTION_KEY_LENGTH)) { getBytesFromStream(buffer, WALLET_ENCRYPTION_KEY_LENGTH); setEncryptionKey(buffer); wallet_return = initWallet(); translateWalletError(wallet_return, 0, NULL); } break; case PACKET_TYPE_UNLOAD_WALLET: // Unload wallet. if (!expectLength(0)) { clearEncryptionKey(); sanitiseRam(); memset(buffer, 0xff, sizeof(buffer)); memset(buffer, 0, sizeof(buffer)); wallet_return = uninitWallet(); translateWalletError(wallet_return, 0, NULL); } break; case PACKET_TYPE_FORMAT: // Format storage. if (!expectLength(0)) { if (askUser(ASKUSER_FORMAT)) { writeString(STRINGSET_MISC, MISCSTR_PERMISSION_DENIED, PACKET_TYPE_FAILURE); } else { wallet_return = sanitiseNonVolatileStorage(0, 0xffffffff); translateWalletError(wallet_return, 0, NULL); uninitWallet(); // force wallet to unload } } break; case PACKET_TYPE_CHANGE_KEY: // Change wallet encryption key. if (!expectLength(WALLET_ENCRYPTION_KEY_LENGTH)) { getBytesFromStream(buffer, WALLET_ENCRYPTION_KEY_LENGTH); wallet_return = changeEncryptionKey(buffer); translateWalletError(wallet_return, 0, NULL); } break; case PACKET_TYPE_CHANGE_NAME: // Change wallet name. if (!expectLength(NAME_LENGTH)) { getBytesFromStream(buffer, NAME_LENGTH); if (askUser(ASKUSER_CHANGE_NAME)) { writeString(STRINGSET_MISC, MISCSTR_PERMISSION_DENIED, PACKET_TYPE_FAILURE); } else { wallet_return = changeWalletName(buffer); translateWalletError(wallet_return, 0, NULL); } } break; case PACKET_TYPE_LIST_WALLETS: // List wallets. if (!expectLength(0)) { listWallets(); } break; default: // Unknown command. readAndIgnoreInput(); writeString(STRINGSET_MISC, MISCSTR_INVALID_PACKET, PACKET_TYPE_FAILURE); break; } #ifdef TEST_STREAM_COMM assert(payload_length == 0); #endif }
void sortMenu() { char choice; system('cls'); printf("[1]-INSERTION SORT\n[2]-SELECTION SORT\n[3]-BUBBLE SORT\n[4]-BUCKET SORT\n[5]-HEAP SORT\n[6]-QUICK SORT\n[7]-RADIX SORT\n[8]-COMB SORT\n[9]-MERGE SORT\n[0]-SHELL SORT\n"); printf("Press any key in order to return to MAIN MENU..."); choice=getche(); switch(choice) { case '1': //insertion sortInsert(); getch(); sortMenu(); break; case '2': //selection getch(); sortMenu(); break; case '3': //bubble //bubbleSort(parameter1); getch(); sortMenu(); break; case '4': //bucket getch(); sortMenu(); break; case '5': //heap getch(); sortMenu(); break; case '6': //quick //QuickSortList(parameter1,parameter2); getch(); sortMenu(); break; case '7': //radix getch(); sortMenu(); break; case '8': //comb getch(); sortMenu(); break; case '9': //merge //mergesort(parameter1) getch(); sortMenu(); break; case '0': //shell getch(); sortMenu(); break; default: getch(); askUser(); break; } }
int main () // "Guess the word" game in OCR lessons. { std::string wannaPlay; int gameAmounts=0; int gameWin=0; int defeats=0; int attempts=0; do { bool isGuessedResult = false; int numberAttempts=0; std::string const dictionnaryDirectory("C:/Users/user/dico.txt"); std::string word(pickOneWord(dictionnaryDirectory)); std::string mixedWord (mixtureWord(word)); std::string guessWord (askUser ("Guess the following word in the correct order: " + mixedWord + " \n")); gameAmounts++; while (isGuessedResult == false)//int guessResult = 0; ==> wasn't clear enough, replace with isGuessedResult { if ((guessWord!=word) && (numberAttempts!=4)) { attempts++; numberAttempts++; guessWord=askUser("You are wrong, try again "); } else if (guessWord==word) { gameWin++; isGuessedResult = true; wannaPlay = (askUser("Wanna play again? [yes/no] ")); } else if ((guessWord!=word) && (numberAttempts==4)) { defeats++; isGuessedResult = true; wannaPlay = (askUser("The solution was " + word + ". \n" "Wanna play again? [yes/no] ")); while ((wannaPlay != "no") && (wannaPlay != "n") && (wannaPlay != "yes") && (wannaPlay != "y")) { wannaPlay = (askUser("Wanna play again? [yes/no] ")); } } } word.clear(); mixedWord.clear(); guessWord.clear(); isGuessedResult = true; } while ((wannaPlay != "no") && (wannaPlay != "n")); gameStatistics(gameAmounts,gameWin,defeats,attempts); //clearing all variable. wannaPlay.clear(); gameAmounts = 0; gameWin = 0; defeats = 0; attempts = 0; //end of program exit(EXIT_SUCCESS); }
extern "C" KDE_EXPORT int kdemain(int argc, char **argv) { KLocale::setMainCatalogue("konqueror"); KAboutData aboutData("keditbookmarks", I18N_NOOP("Bookmark Editor"), VERSION, I18N_NOOP("Konqueror Bookmarks Editor"), KAboutData::License_GPL, I18N_NOOP("(c) 2000 - 2003, KDE developers")); aboutData.addAuthor("David Faure", I18N_NOOP("Initial author"), "*****@*****.**"); aboutData.addAuthor("Alexander Kellett", I18N_NOOP("Author"), "*****@*****.**"); KCmdLineArgs::init(argc, argv, &aboutData); KApplication::addCmdLineOptions(); KCmdLineArgs::addCmdLineOptions(options); KCmdLineArgs *args = KCmdLineArgs::parsedArgs(); bool isGui = !(args->isSet("exportmoz") || args->isSet("exportns") || args->isSet("exporthtml") || args->isSet("exportie") || args->isSet("exportopera") || args->isSet("importmoz") || args->isSet("importns") || args->isSet("importie") || args->isSet("importopera")); bool browser = args->isSet("browser"); KApplication::disableAutoDcopRegistration(); KApplication app(isGui, isGui); bool gotArg = (args->count() == 1); QString filename = gotArg ? QString::fromLatin1(args->arg(0)) : locateLocal("data", QString::fromLatin1("konqueror/bookmarks.xml")); if(!isGui) { CurrentMgr::self()->createManager(filename); CurrentMgr::ExportType exportType = CurrentMgr::MozillaExport; // uumm.. can i just set it to -1 ? int got = 0; const char *arg, *arg2 = 0, *importType = 0; if(arg = "exportmoz", args->isSet(arg)) { exportType = CurrentMgr::MozillaExport; arg2 = arg; got++; } if(arg = "exportns", args->isSet(arg)) { exportType = CurrentMgr::NetscapeExport; arg2 = arg; got++; } if(arg = "exporthtml", args->isSet(arg)) { exportType = CurrentMgr::HTMLExport; arg2 = arg; got++; } if(arg = "exportie", args->isSet(arg)) { exportType = CurrentMgr::IEExport; arg2 = arg; got++; } if(arg = "exportopera", args->isSet(arg)) { exportType = CurrentMgr::OperaExport; arg2 = arg; got++; } if(arg = "importmoz", args->isSet(arg)) { importType = "Moz"; arg2 = arg; got++; } if(arg = "importns", args->isSet(arg)) { importType = "NS"; arg2 = arg; got++; } if(arg = "importie", args->isSet(arg)) { importType = "IE"; arg2 = arg; got++; } if(arg = "importopera", args->isSet(arg)) { importType = "Opera"; arg2 = arg; got++; } if(!importType && arg2) { Q_ASSERT(arg2); // TODO - maybe an xbel export??? if(got > 1) // got == 0 isn't possible as !isGui is dependant on "export.*" KCmdLineArgs::usage(I18N_NOOP("You may only specify a single --export option.")); QString path = QString::fromLocal8Bit(args->getOption(arg2)); CurrentMgr::self()->doExport(exportType, path); } else if(importType) { if(got > 1) // got == 0 isn't possible as !isGui is dependant on "import.*" KCmdLineArgs::usage(I18N_NOOP("You may only specify a single --import option.")); QString path = QString::fromLocal8Bit(args->getOption(arg2)); ImportCommand *importer = ImportCommand::importerFactory(importType); importer->import(path, true); importer->execute(); CurrentMgr::self()->managerSave(); CurrentMgr::self()->notifyManagers(); } return 0; // error flag on exit?, 1? } QString address = args->isSet("address") ? QString::fromLocal8Bit(args->getOption("address")) : QString("/0"); QString caption = args->isSet("customcaption") ? QString::fromLocal8Bit(args->getOption("customcaption")) : QString::null; args->clear(); bool readonly = false; // passed by ref if(askUser(app, (gotArg ? filename : QString::null), readonly)) { KEBApp *toplevel = new KEBApp(filename, readonly, address, browser, caption); toplevel->show(); app.setMainWidget(toplevel); return app.exec(); } return 0; }
void askUser() { int num; int x=10; int i; char choices; system("cls"); printf("\n[1]-DISPLAY ARRAY\n[2]-INSERT REAR\n[3]-INSERT FRONT\n[4]-INSERT INTO\n[5]-DELETE FRONT\n[6]-DELETE REAR\n[7]-DELETE ITEM\n[8]-DELETE ALL ITEM\n[9]-MAKE UNIQUE\n"); choices=getch(); switch(choices) { case '1': displayArray(); getch(); askUser(); break; case '2': num=askNum(); for(i=0;i<num;i++) { while(x<0||x>9) { printf("Enter number: "); scanf("%d",&x); } insertRear(x); x=10; displayArray(); } getch(); askUser(); break; case '3': num=askNum(); for(i=0;i<num;i++) { while(x<0||x>9) { printf("Enter number: "); scanf("%d",&x); } insertFront(x); x=10; displayArray(); } getch(); askUser(); break; case '4': displayArray(); insertInto(); displayArray(); getch(); askUser(); break; case '5': deleteFront(); displayArray(); getch(); askUser(); break; case '6': deleteRear(); displayArray(); getch(); askUser(); break; case '7': displayArray(); deleteItem(); displayArray(); getch(); askUser(); break; case '8': displayArray(); deleteAllItem(); displayArray(); getch(); askUser(); break; case '9': displayArray(); makeUnique(); displayArray(); getch(); askUser(); break; default: getch(); break; } }
int main() { startup(); updateUsers(); loadSettings(); while(!vars::accepted) { getmaxyx(stdscr, vars::maxY, vars::maxX); erase(); firstNotice(); if(!vars::running) break; refresh(); } vars::noticeText.scroll = 0; while(vars::running) {//Main loop updateColors(); updateUsers(); if((vars::userList.at(vars::yourself).stat == 0) || ((!vars::chatting) && (!vars::banning)) || ((vars::about) && (!vars::settingsChangingDescription) && (!vars::settingsChangingNickname))) curs_set(0); else curs_set(1); getmaxyx(stdscr, vars::maxY, vars::maxX); erase(); if((vars::maxX < 80) || (vars::maxY < 20)) { printw("The console window size is too small.\nPlease resize it to at least 80 * 20 width and height respectively.\nPress [Esc] or [Ctrl]+[C] to quit if resizing is not possible."); if(getch() == 27) vars::running = false; } else { printMainframe(); if(vars::about) about(); else { if(vars::menu == 0) { notifications(); askUser(); } else if(vars::menu == 1) chatFrame(); } } if((vars::previousState != 4) && (vars::previousState != vars::userList.at(vars::yourself).stat)) { //Check if your user stat changed curs_set(0); unsigned char thisState = vars::userList.at(vars::yourself).stat; if((vars::previousState > 0) && (thisState == 0)) { broadcast(std::vector < std::string >(1, "You have been banned!"), 6); vars::input.clear(); vars::chattingWith.clear(); vars::yourStr.clear(); vars::menu = 0; vars::chatting = true; vars::chatScroll = -1; flushinp(); } else if((vars::previousState == 0) && (thisState == 1)) broadcast(std::vector < std::string >(1, "You have been unbanned!"), 8); else if((vars::previousState == 2) && (thisState == 1)) broadcast(std::vector < std::string >(1, "You have been demoted!"), 6); else if((vars::previousState < 2) && (thisState == 2)) broadcast(std::vector < std::string >(1, "You have been promoted to moderator!"), 8); broadcastWait(10); } else if(vars::broadcast.size() > 0) { //Or just draw a broadcast to the screen if there is one being sent. curs_set(0); broadcast(vars::broadcast, 6); vars::broadcast.clear(); broadcastWait(10); } else { parseInput(); refresh(); } vars::previousState = vars::userList.at(vars::yourself).stat; } endwin(); return 0; }