void WizUpdaterDialog::doUpdateApp()
{
// read metadata
QList<QStringList> files;
setGuiNotify("Prepare upgrade");
QString strConfig = ::WizGetUpgradePath() + "config.txt";
WizSettings* config = new WizSettings(strConfig);
int i = 0;
QString strFileEntry = config->getString("Files", QString::number(i));
while (!strFileEntry.isEmpty()) {
QStringList strFileMeta = strFileEntry.split("*");
QStringList strFile;
strFile << strFileMeta.at(0) << strFileMeta.at(1);
files.append(strFile);
i++;
strFileEntry = config->getString("Files", QString::number(i));
}
QList<QStringList>::const_iterator it;
for(it = files.constBegin(); it!= files.constEnd(); it++) {
QString strLocal = ::WizGetAppPath() + (*it).at(0);
QString strLocalPath = ::WizExtractFilePath(strLocal);
QString strUpdate = ::WizGetUpgradePath() + (*it).at(0);
QString strUpdatePath = ::WizExtractFilePath(strUpdate);
QFile fileUpdate(strUpdate);
if (fileUpdate.exists()) {
// compare MD5
QString md5Remote = (*it).at(1);
QString md5Download = ::WizMd5FileString(strUpdate);
if (md5Remote == md5Download) {
::WizEnsurePathExists(strLocalPath);
fileUpdate.copy(strLocal);
fileUpdate.remove();
setGuiNotify(QString("Copying %1").arg(strLocal));
}
}
::WizDeleteFolder(strUpdatePath);
}
// remove config file
QFile fileConfig(strConfig);
fileConfig.remove();
QFile fileZip(::WizGetUpgradePath() + "update.zip");
fileZip.remove();
// remove stub
QFile fileStub(::WizGetUpgradePath() + "WIZNOTE_READY_FOR_UPGRADE");
fileStub.remove();
setGuiNotify("Upgrade done");
ui->progressUpdate->setValue(ui->progressUpdate->maximum());
}
bool WizUpdaterDialog::needUpdateApp()
{
// check stub here, created by CWizUpdaterNotifyDialog
QFile fileUpdate(QDir::homePath() + "/.wiznote/update/WIZNOTE_READY_FOR_UPGRADE");
if (fileUpdate.exists()) {
m_bUpdateApp = true;
}
return m_bUpdateApp;
}
//*******************************************************************************************************************************
// schließt die datei operation ab. eigentlich nur nötig wenn geschrieben wurde. es gibt 2 möglichkeiten :
// 1. die datei wird geschlossen und es wurde über die alte datei länge hinaus geschrieben.
// 2. die datei wird geschlossen und man war innerhalb der datei größe, dann muss nur der aktuelle sektor geschrieben werden.
// der erste fall ist komplizierter, weil ermittelt werden muss wie viele sektoren neu beschrieben wurden um diese zu verketten
// und die neue datei länge muss ermitt weden. abschließend wird entweder (fall 2) nur der aktuelle sektor geschrieben, oder
// der aktuallisierte datei eintrag und die cluster (diese werden verkettet, siehe fileUpdate() ).
//*******************************************************************************************************************************
unsigned char ffclose(void){
#if (WRITE==1) /** 2 möglichkeiten beim schließen !! (lesend spielt keine rolle, nichts muss geupdatet werden) **/
if( file.length < (file.seek+file.cntOfBytes) ) fileUpdate(); /** 1.) es wurde über die alte datei größe hinaus geschrieben **/
else if( fat.bufferDirty==1) fat_writeSector( fat.currentSectorNr ); /** 2.) nicht über alte datei länge hinaus **/
#endif
file.cntOfBytes=0; // init werte der nötigen zähler
file.seek=0;
return(0);
}
/// Constructor
TUIFileBrowserButton::TUIFileBrowserButton(int id, int type, QWidget *w, int parent, QString name)
: TUIElement(id, type, w, parent, name)
{
QPushButton *b = new QPushButton(w);
if (name.contains("."))
{
QPixmap pm(name);
if (pm.isNull())
{
QString covisedir = QString(getenv("COVISEDIR"));
QPixmap pm(covisedir + "/" + name);
if (pm.isNull())
{
b->setText(name);
}
else
{
b->setIcon(pm);
}
}
else
{
b->setIcon(pm);
}
}
else
b->setText(name);
//b->setFixedSize(b->sizeHint());
//std::cerr << "Creating new Filebrowser instance!" << std::endl;
this->mFileBrowser = new FileBrowser(this, 0, id);
connect(this, SIGNAL(dirUpdate(QStringList)), this->mFileBrowser, SLOT(handleDirUpdate(QStringList)));
connect(this, SIGNAL(fileUpdate(QStringList)), this->mFileBrowser, SLOT(handleFileUpdate(QStringList)));
connect(this, SIGNAL(clientUpdate(QStringList)), this->mFileBrowser, SLOT(handleClientUpdate(QStringList)));
/*connect(this,SIGNAL(filterUpdate(QStringList)),this->mFileBrowser, SLOT(handleFilterUpdate(QStringList)));*/
connect(this, SIGNAL(curDirUpdate(QString)), this->mFileBrowser, SLOT(handleCurDirUpdate(QString)));
connect(this, SIGNAL(driveUpdate(QStringList)), this->mFileBrowser, SLOT(handleDriveUpdate(QStringList)));
connect(this, SIGNAL(updateMode(int)), this->mFileBrowser, SLOT(handleUpdateMode(int)));
connect(this, SIGNAL(updateFilterList(char *)), this->mFileBrowser, SLOT(handleUpdateFilterList(char *)));
connect(this, SIGNAL(locationUpdate(QString)), this->mFileBrowser, SLOT(handleLocationUpdate(QString)));
connect(this, SIGNAL(updateRemoteButtonState(int)), this->mFileBrowser, SLOT(handleupdateRemoteButtonState(int)));
connect(this, SIGNAL(updateLoadCheckBox(bool)), this->mFileBrowser, SLOT(handleUpdateLoadCheckBox(bool)));
mFileBrowser->setWindowTitle("TabletUI VRML - Remote File Browser");
widget = b;
connect(b, SIGNAL(pressed()), this, SLOT(onPressed()));
}
// *******************************************************************************************************************************
// offset byte wird übergeben. es wird durch die sektoren der datei gespult (gerechnet), bis der sektor mit dem offset byte erreicht
// ist, dann wird der sektor geladen und der zähler für die bytes eines sektors gesetzt. wenn das byte nicht in den sektoren ist,
// die "vorgesucht" wurden, müssen noch weitere sektoren der datei gesucht werden (sec > fat.endSectors).
// *******************************************************************************************************************************
void ffseek(unsigned long int offset){
#if (OVER_WRITE==1) // man muss den dateieintrag updaten, um die daten zu retten !!
if( file.seek > file.length ) fileUpdate(); // fat verketten und datei update auf der karte !
#endif
fat_getFatChainClustersInRow(file.firstCluster); // suchen von anfang der cluster chain aus !
unsigned long int sec=fat.startSectors; // sektor variable zum durchgehen durch die sektoren
file.seek=0; // weil auch von anfang an der chain gesucht wird mit 0 initialisiert
while(offset>=512){ /** suchen des sektors in dem offset ist **/
sec++; // da byte nicht in diesem sektor ist, muss hochgezählt werden
offset-=512; // ein sektor weniger in dem das byte sein kann
file.seek+=512; // file.seek update, damit bei ffclose() die richtige file.length herauskommt
if ( sec > fat.endSectors ){ // es müssen mehr sektoren der datei gesucht werden
fat_getFatChainClustersInRow(fat_getNextCluster( file.lastCluster ) ); // nachladen von clustern in der chain
sec=fat.startSectors; // setzen des 1. sektors der neu geladenen, zum weitersuchen !
}
}
file.lastCluster=fat_secToClust(fat.endSectors); // letzter bekannter cluster der datei
fat_loadSector(sec); // sektor mit offset byte laden
file.cntOfBytes = offset; // setzen des lese zählers
}
int main(int argc, char *argv[]){
int i;
record* mod;
char *command;
fileName = argv[1];
phoneBookFile = fopen(fileName,"r+");
if(phoneBookFile == NULL){
phoneBookFile = fopen(fileName,"w+");
//printf("%s\n", "File not found, so was created");
}
phoneBook.size = 0;
head = phoneBook.persons;
rewind(phoneBookFile);
current.id = -1;
while (!feof(phoneBookFile)){
fscanf(phoneBookFile, "%d", ¤t.id);
current.name = read(phoneBookFile);
current.phoneNumber = read(phoneBookFile);
createRecord(current.id, current.name, current.phoneNumber);
}
maxId = (current.id > maxId) ? current.id : maxId;
maxId++;
while( true ){
command = read(stdin);
if(strcmp(command, "create") == 0){
current.name = read(stdin);
current.phoneNumber = read(stdin);
if(isCorrectName(current.name) && stabilizationPhoneNumber(current.phoneNumber)){
createRecord(maxId, current.name, current.phoneNumber);
maxId++;
fileUpdate();
}
} else if(strcmp(command, "delete") == 0){
scanf("%d", ¤t.id);
mod = getIdPrePosition(current.id);
if(mod != NULL ){
deleteRecord(mod);
phoneBook.size--;
fileUpdate();
} else {
//printf("%s\n", "ID not found.");
}
} else if(strcmp(command, "change") == 0){
scanf("%d ", ¤t.id);
mod = getIdPrePosition(current.id);
if(mod != NULL){
temp = mod->next;
command = read(stdin);
if(strcmp(command,"name") == 0){
current.name = read(stdin);
if(isCorrectName(current.name)){
strcpy(temp->name, current.name);
} else {
//printf("%s%s\n", "Not correct new name : ", current.name);
}
} else if(strcmp(command,"number") == 0){
current.phoneNumber = read(stdin);
if(stabilizationPhoneNumber(current.phoneNumber)){
strcpy(temp->phoneNumber, current.phoneNumber);
}
} else {
//printf("%s \"%s\" %s\n","Operation" , command, "is not defined");
}
fileUpdate();
} else {
//printf("%s\n", "ID not found.");
}
} else if(strcmp(command, "find") == 0){
command = read(stdin);
if(strlen(command) > 0){
bool f1, f2, isFound;
isFound = false;
f1 = isCorrectName(command);
if(!f1){
stabilizationPhoneNumber(command);
} else {
command = alphaToLower(command);
}
temp = head;
for (i = 0; i < phoneBook.size; i++){
f2 = false;
if(f1){//name
if(strstr(alphaToLower(temp->name), command)){
f2 = true;
}
} else{//number
if(strcmp(temp->phoneNumber, command) == 0){
f2 = true;
}
}
if(!isFound && f2){
isFound = true;
}
if(f2){
printf("%d ", temp->id);
printf("%s %s\n", temp->name, temp->phoneNumber);
}
temp = temp->next;
}
if(!isFound){
//printf("Not found.\n");
}
} else {
//printf("%s\n", "You did not enter anything.");
}
} else if(strcmp(command, "exit") == 0){
free(command);
fclose(phoneBookFile);
free(phoneBook.persons);
break;
} else {
//printf("%s \"%s\" %s\n","Operation" , command, "is not defined");
}
fflush(phoneBookFile);
fflush(stdout);
}
return 0;
}
