Avoid crash if app was unable to open the file

2 files changed, 7 insertions, 3 deletions

diff --git a/noncore/apps/opie-sheet/Excel.cpp b/noncore/apps/opie-sheet/Excel.cpp
index 57aef20..338bc30 100644
--- a/noncore/apps/opie-sheet/Excel.cpp
+++ b/noncore/apps/opie-sheet/Excel.cpp
@@ -208,769 +208,770 @@ bool ExcelBook::OpenFile(char *Filename)
     Names.resize(0);
     Sheets.resize(0);
     if(File==NULL) return false;
     printf("Opened excel file!\r\n");
     return true;
 };
 
 bool ExcelBook::CloseFile(void)
 {
     int w1;
     for(w1=0;w1<(int)XFRecords.count();w1++)
     {
         if(XFRecords[w1]!=NULL) {delete XFRecords[w1];XFRecords[w1]=NULL;};
     };
     for(w1=0;w1<(int)SharedStrings.count();w1++)
     {
         if(SharedStrings[w1]!=NULL) {delete SharedStrings[w1];SharedStrings[w1]=NULL;};
     };
     for(w1=0;w1<(int)Names.count();w1++)
     {
         if(Names[w1]!=NULL) {delete Names[w1];Names[w1]=NULL;};
     };
     for(w1=0;w1<(int)Sheets.count();w1++)
     {
         if(Sheets[w1]!=NULL) {delete Sheets[w1];Sheets[w1]=NULL;};
     };
     XFRecords.resize(0);
     SharedStrings.resize(0);
     Names.resize(0);
     Sheets.resize(0);
     fclose(File);
     printf("closed excel file!\r\n");
     if(File==NULL) return true;
     return false;
 };
 
 void ExcelBook::SeekPosition(int pos)
 {
     if(!feof(File))
     {
         Position=pos;
         //printf("SeekPosition:Pos:%d\r\n",Position);
         fseek(File,pos,SEEK_SET);
     };
 };
 
 void ExcelBook::SeekSkip(int pos)
 {
     if(!feof(File))
     {
         Position=Position+pos;
         //printf("SeekSkip:Pos:%d\r\n",Position);
         fseek(File, Position, SEEK_SET);
     };
 };
 
 int ExcelBook::FileEOF(void)
 {
     if(File!=NULL) return(feof(File)); else return 0;
     //EOF is defined in stdlib as -1
 };
 
 int ExcelBook::Get2Bytes(void)
 {
     int i1,i2;
     i1=0; i2=0;
     if (!feof(File))
     {
         i1=fgetc(File);
         Position++;
     };
     if (!feof(File))
     {
         i2=fgetc(File);
         Position++;
     };
     return Integer2Byte(i1,i2);
 };
 
 char* ExcelBook::Read(int pos, int length)
 {
     int i;
     char *data;
     data= new char[length];
     SeekPosition(pos);
     for(i=0; i<length; i++)
     {
         if(!feof(File)) data[i]=fgetc(File);
     };
     Position= Position+length;
     return data;
 };
 
 QString ExcelBook::ReadUnicodeChar(int pos, int length)
 {
     int i;
     QString data;
     int i1=' ',i2=' ',ii;
     SeekPosition(pos);
     for(i=0; i<length; i++)
     {
         if(!feof(File)) i1=fgetc(File);
         if(!feof(File)) i2=fgetc(File);
         ii=Integer2Byte(i1,i2);
         data.append(ii);
         Position+=2;
     };
     return data;
 };
 
 QString* ExcelBook::GetString(int num)
 {
     if(num>=0 && num<(int)SharedStrings.count())
     {
         return SharedStrings[num];
     };
     return new QString("");
 };
 
 int ExcelBook::SeekBOF(void)
 {
     int opcode,version,streamtype,length,ret=0;
     char *data;
     while(!feof(File))
     {
         opcode=Get2Bytes();
         if(opcode==XL_BOF)
         {
             length=Get2Bytes();
             data=Read(Position,length);
             version=Integer2Byte(data[0], data[1]);
             streamtype=Integer2Byte(data[2], data[3]);
             printf("SEEKBOF:opcode=XLBOF, %d ,version %d\r\n",Position,version);
             delete data; data=NULL;
             if (version==BIFF8) ret=8;
             else if(version==BIFF7) ret=7;
             printf("SEEKBOF:versionBIFF%d\r\n",ret);
             if(streamtype==WBKGLOBAL) return ret *2;
             else if(streamtype==WRKSHEET) return ret *1;
             return 1;
         };
     };
     return 0;
 };
 
 ExcelBREC* ExcelBook::GetBREC(void)
 {
     ExcelBREC* rec;
     rec= new ExcelBREC;
     if(FileEOF()) return NULL;
     rec->data=NULL;
     rec->code=Get2Bytes();
     rec->length=Get2Bytes();
     rec->position=Position;
     SeekSkip(rec->length);
     return rec;
 };
 
 ExcelBREC* ExcelBook::PeekBREC(void)
 {
     int oldpos;
     ExcelBREC* NextRec;
     oldpos=Position;
     NextRec=GetBREC();
     SeekPosition(oldpos);
     return NextRec;
 };
 
 char* ExcelBook::GetDataOfBREC(ExcelBREC* record)
 {
     if(record->data==NULL)
     {
         ConvertCharToArray(record,Read(record->position,record->length),record->length);
     };
     return record->data;//new?
 };
 
 void ExcelBook::ConvertCharToArray(ExcelBREC* record, char* chars, int length)
 {
     record->data=new char[length];
     for(int w1=0;w1<=length-1;w1++)
         record->data[w1]=chars[w1];
 };
 
 
 bool ExcelSheet::InitCells()
 {
     int r;
     Cells.resize(rows * cols + cols+1);
     if(Cells.count()==0) return false;
     for(r=0;r < Cells.count();r++)
     {
         Cells[r]=NULL;
     };
     return true;
 };
 
 void ExcelSheet::Set(int row, int col, ExcelCell* cell)
 {
     if(cell!=NULL&&(row*cols+col)<Cells.count())
     {
         Cells[row*cols+col]=cell;
     };
 };
 
 ExcelCell* ExcelSheet::Get(int row, int col)
 {
     ExcelCell* cell;
     cell=Cells[row*cols+col];
     if(cell==NULL) return NULL;
     return cell;
 };
 
 int ExcelBook::SheetHandleRecord(ExcelSheet* sheet, ExcelBREC* record)
 {
     char* data=NULL;
     switch (record->code)
     {
     case XL_DIMENSION:
         data = GetDataOfBREC(record);
         if (record->length == 10)
         {
             sheet->rows = Integer2Byte(data[2], data[3]);
             sheet->cols = Integer2Byte(data[6], data[7]);
         }
         else
         {
             sheet->rows = Integer4Byte(data[4], data[5], data[6], data[7]);
             sheet->cols = Integer2Byte(data[10], data[11]);
         }
         sheet->InitCells();
         break;
 
     case XL_LABELSST:
         HandleLabelSST(sheet, record);
         break;
 
     case XL_RK:
     case XL_RK2:
         HandleRK(sheet, record);
         break;
 
     case XL_MULRK:
         HandleMulrk(sheet, record);
         break;
 
     case XL_ROW:
         break;
 
     case XL_NUMBER:
         HandleNumber(sheet, record);
         break;
 
     case XL_BOOLERR:
         break;
 
     case XL_CONTINUE:
         break;
 
     case XL_FORMULA:
     case XL_FORMULA2:
         HandleFormula(sheet, record);
         break;
 
     case XL_LABEL:
         break;
 
     case XL_NAME:
         HandleName(sheet, record);
         break;
 
     case XL_BOF:
         break;
     case XL_EOF:
         return 0;
     default:
         break;
     };
     return 1;
 };
 
 int ExcelBook::ReadSheet(ExcelSheet* sheet)
 {
     ExcelBREC* record;
     int oldpos;
     oldpos = Position;
     SeekPosition(sheet->position);
     record = GetBREC();
     while (record!=NULL)
     {
         if (!SheetHandleRecord(sheet, record)) break;
         record=GetBREC();
     };
     SeekPosition(oldpos);
     return 1;
 };
 
 ExcelSheet* ExcelBook::GetSheet(void)
 {
     ExcelSheet* sh=NULL;
     int type;
     type=SeekBOF();
     Version=type;
     sh=new ExcelSheet;
     if(type)
     {
         sh->type=type;
         sh->position=Position;
         sh->name=QString("");
     };
     if(type==8||type==7)
     {
         ReadSheet(sh);
     };
     return sh;
 };
 
 void ExcelBook::ParseSheets(void)
 {
     int BOFs;
     ExcelBREC* r;
     BOFs=1;
     r=GetBREC();
     while(BOFs)
     {
         r=GetBREC();
         switch(r->code)
         {
         case XL_SST:
             HandleSST(r);
             break;
 
         case XL_TXO:
             break;
         case XL_NAME:
             break;
         case XL_ROW:
             break;
 
         case XL_FORMAT:
             HandleFormat(r);
             break;
 
         case XL_XF:
             HandleXF(r);
             break;
 
         case XL_BOUNDSHEET:
             HandleBoundSheet(r);
             break;
 
         case XL_EXTSST:
             break;
         case XL_CONTINUE:
             break;
 
         case XL_EOF:
             BOFs--;
             break;
 
         default:
             break;
         };
     };
 };
 
 void ExcelBook::GetSheets(void)
 {
     ExcelSheet* sheet;
     Sheets.resize(0);
     sheet=GetSheet();
     while (sheet->Cells.count()!= 0 )
     {
         Sheets.resize(Sheets.count()+1);
         Sheets[Sheets.count()-1]=sheet;
         sheet->name=*Names[Sheets.count()-1];
         sheet=GetSheet();
     };
 };
 
 bool ExcelBook::ParseBook(char *file)
 {
     dateformat=QString("");
     DetectEndian();
-    OpenFile(file);
+    if ( !OpenFile( file ) )
+	    return false;
     SeekBOF();
     ParseSheets();
     GetSheets();
     return true;
 };
 
 QString ExcelBook::GetASCII(char* inbytes, int pos, int chars)
 {
     int i;
     QString outstr="";
     for (i = 0; i < chars; i++)
     {
         outstr.append(inbytes[i+pos]);
     };
     return outstr;
 };
 
 QString ExcelBook::GetUnicode(char * inbytes, int pos, int chars)
 {
     QString outstr="";
     int i;
     int rc;
     for (i=0; i<chars*2; i++)
     {
         rc=Integer2Byte(inbytes[i+pos],inbytes[i+pos+1]);
         outstr.append(QChar(rc));
         i++;
     };
     return outstr;
 };
 
 
 void ExcelBook::HandleBoundSheet(ExcelBREC* rec)
 {
     char* data;
     int type;
     int visibility;
     int length;
     int pos;
     QString name;
     pos = 8;
     data   = GetDataOfBREC(rec);
     type = data[4];
     visibility = data[5];
     length = data[6];
     if(data[7]==0)
     {
         //ascii
         name=GetASCII(data,pos,length);
     }
     else
     {
         name=GetUnicode(data,pos,length);
     };
     Names.resize(Names.count()+1);
     Names[Names.count()-1]=new QString(name);
 };
 
 void ExcelBook::HandleName(ExcelSheet* sheet, ExcelBREC* rec)
 {
     char* data;
     QString name;
     int length;
     int pos;
     pos = 15;
     data   = GetDataOfBREC(rec);
     length = data[3];
     name = GetASCII(data,pos,length);
 
 
 };
 
 ExcelFormat* ExcelBook::GetFormatting(int xf)
 {
     int i;
     ExcelFormat* rec;
     rec=new ExcelFormat();
     for (i = 0; formatter[i].code != 0; i++)
     {
         if (xf == formatter[i].code) break;
     };
     if (formatter[i].format ==NULL) return NULL;
     rec->code   = xf;
     rec->type   = formatter[i].type;
     rec->format = formatter[i].format;
     return rec;
 };
 
 void ExcelBook::HandleSetOfSST(ExcelBREC* rec/*, SSTList* cont*/, char* bytes)
 {
     QString str=QString("");
     char* data;
     int chars, pos, options, i;
     int richstring, fareaststring, runlength=0;
     int richruns=0,fareastsize=0;
     int totalstrings;
     int uniquestrings;
     data = GetDataOfBREC(rec);
     totalstrings  = Integer4Byte(data[0], data[1], data[2], data[3]);
     uniquestrings = Integer4Byte(data[4], data[5], data[6], data[7]);
     pos = 8;
     for (i = 0; i < uniquestrings; i++)
     {
         richruns=0; fareastsize=0;
         chars = Integer2Byte(data[pos], data[pos+1]);
         pos += 2;
         options = data[pos];
         pos++;
         fareaststring = ((options & 0x04) != 0);
         richstring     = ((options & 0x08) != 0);
         if(richstring)
         {
             richruns= Integer2Byte(data[pos],data[pos+1]);
             pos+=2;
         };
         if(fareaststring)
         {
             fareastsize=Integer4Byte(data[pos], data[pos+1], data[pos+2], data[pos+3]);
             pos+=4;
         };
 
         if ((options & 0x01) == 0) //8 bit chars
         {
             /* ascii */
             str = GetASCII(bytes,pos,chars);
             pos=pos+chars;
             if(str[0]=='=') str[0]=' ';
         }else //16 bit chars
         {
             /* unicode */
             str = GetUnicode(bytes,pos,chars);
             pos=pos+chars*2;
         };
         // HERE TO PUT richformat handling
         if (richstring)
         {
             pos += 4 * richruns;
         };
         if (fareaststring)
         {
             pos += fareastsize;
         };
         //printf("String=%s, length=%d first=0x%x\r\n",str.ascii(),str.length(),str[0].unicode());
         SharedStrings.resize(SharedStrings.count()+1);
         SharedStrings[SharedStrings.count()-1]=new QString(str);
     }
 };
 
 
 char* ExcelBook::MergeBytesFromSSTs(ExcelBREC* rec,SSTList* cont)
 {
     int i, pos;
     int length;
 
     char* data;
     char* bytes;
     length = rec->length;
     for (i = 0; i < (int) cont->rec.count(); i++)
     {
         length += cont->rec[i]->length;
     }
     bytes = GetDataOfBREC(rec);
     pos = rec->length;
     for (i = 0; i < (int) cont->rec.count(); i++)
     {
         data = GetDataOfBREC(cont->rec[i]);
         *bytes += pos;
         bytes = data;
         pos += cont->rec[i]->length;
     }
     return bytes;
 };
 
 
 void ExcelBook::HandleSST(ExcelBREC* rec)
 {
     char* bytes;
     SSTList* cont;
     cont= new SSTList;
     ExcelBREC* nr;
     nr = PeekBREC();
     while (nr->code == XL_CONTINUE)
     {
         cont->rec.resize(cont->rec.count()+1);
         cont->rec[cont->rec.count()-1]=GetBREC();
         nr = PeekBREC();
     }
     bytes = MergeBytesFromSSTs(rec,cont);
     HandleSetOfSST(rec, bytes);
     for(int w1=0;w1<(int)cont->rec.count();w1++)
     {
         if(cont->rec[w1]!=NULL) {delete cont->rec[w1];cont->rec[w1]=NULL;};
     };
     cont->rec.resize(0);
 };
 
 void ExcelBook::HandleLabelSST(ExcelSheet* sheet, ExcelBREC* rec)
 {
     int index, row, col;
     char* data;
     data = GetDataOfBREC(rec);
     index = Integer4Byte(data[6], data[7], data[8], data[9]);
     row = Integer2Byte(data[0], data[1]);
     col = Integer2Byte(data[2], data[3]);
     sheet->Set(row,col, CellLabel(row, col, *GetString(index)));
 };
 
 ExcelCell* ExcelBook::CellLabel(int row, int col, QString str)
 {
     ExcelCell* c;
     c= new ExcelCell;
     c->row = row;
     c->col = col;
     c->type = CELL_LABEL;
     c->valuec = str;
     return c;
 };
 
 ExcelCell* ExcelBook::CellNumber(int row, int col, int index, double d)
 {
     ExcelCell* c;
     c=new ExcelCell;
     c->row = row;
     c->col = col;
     c->xfindex = index;
     c->type = CELL_NUMBER;
     c->valued = d;
     return c;
 };
 
 QString* ExcelBook::CellDataString(ExcelSheet* sh, int row, int col)
 {
     time_t date;
     struct tm *tmptr;
     ExcelCell* c;
     char str[128];
     QString format;
     int precision;
     int utcOffsetDays = 25569;
     int sInADay = 24 * 60 * 60;
     c = sh->Get(row,col);
     if (c == NULL) return new QString("");
     switch (c->type)
     {
     case CELL_LABEL:
         return new QString(c->valuec);
     case CELL_NUMBER:
         if (XFRecords[c->xfindex]->type == DATEFORMAT)
         {
 
             format = XFRecords[c->xfindex]->format;
             date = (time_t) ((c->valued - utcOffsetDays) * sInADay);
             tmptr = gmtime(&date);
             if (dateformat)
             {
                 strftime(str,1024,dateformat.ascii(),tmptr);
             }
             else
             {
                 strftime(str,1024,format.ascii(),tmptr);
             };
         }
         else
             if (XFRecords[c->xfindex]->type == NUMBERFORMAT)
             {
                 format = XFRecords[c->xfindex]->format;
                 //sprintf(str,format.ascii(),c->valued);
                 // the real format is ignored...
                 // because there is more work to be done in the field
                 precision = CellGetPrecision(c->valued);
                 sprintf(str,"%.*f",precision,c->valued);
             }
             else
             {
                 precision = CellGetPrecision(c->valued);
                 sprintf(str,"%.*f",precision,c->valued);
             };
         break;
     case CELL_DATE:
         break;
     case CELL_BOOLEAN:
         break;
     case CELL_ERROR:
         break;
     }
     return new QString(str);
 };
 
 int ExcelBook::CellGetPrecision(double d)
 {
     double t;
     int i,x;
     int count;
     if (d < 0) d *= -1;
     i = (int)d;
     t = d - (double)i;
     if (t <= 0)
     {
         return 0;
     };
     count = 0;
     for (x = 6; x > 1; x--)
     {
         i = (int)d;
         t = d - (double)i;
         t *= pow(10,x - 2);
         i = (int)t;
         t = t - (double)i;
         t *= 10;
         i = (int)t;
         if (i > 0) break;
         count++;
     };
     return (5 - count);
 };
 
 
 void ExcelBook::CellSetDateFormat(char *d)
 {
     dateformat = QString(d);
 };
 
 void ExcelBook::HandleMulrk(ExcelSheet* sheet, ExcelBREC* record)
 {
     struct mulrk mulrk;
     char* data;
     ExcelCell* cell;
     int len;
     int i;
     len = record->length;
     data = GetDataOfBREC(record);
     mulrk.row   = Integer2Byte(data[0],data[1]);
     mulrk.first = Integer2Byte(data[2],data[3]);
     mulrk.last  = Integer2Byte(data[len - 2],data[len - 1]);
     mulrk.numrks = mulrk.last - mulrk.first + 1;
     MulrkRead(&mulrk, data);
     for (i = 0; i < mulrk.numrks; i++)
     {
         cell = CellNumber(mulrk.row, mulrk.first + i, mulrk.xfindices[i], mulrk.rkdbls[i]);
         sheet->Set(mulrk.row,mulrk.first+ i, cell);
         //printf("handleMULRK:row=%d,col=%d,val=%f\r\n",mulrk.row,mulrk.first+i,mulrk.rkdbls[i]);
     }
     //delete(mulrk.xfindices);
     //delete(mulrk.rkdbls);
 };
 
 void ExcelBook::MulrkRead(struct mulrk *mulrk, char* data)
 {
     double d;
     int i;
     int pos;
     pos = 4;
     mulrk->xfindices.resize(mulrk->numrks);
     mulrk->rkdbls.resize(mulrk->numrks);
     for (i = 0; i < mulrk->numrks; i++)
     {
         mulrk->xfindices[i] = Integer2Byte(data[pos], data[pos+1]);
         d=Double4Byte(data[pos+2], data[pos+3], data[pos+4], data[pos+5]);
         //printf("double:%f\r\n",d);
         mulrk->rkdbls[i] = d;
         pos += 6;
     }
 };
 
 
 void ExcelBook::HandleNumber(ExcelSheet* sheet, ExcelBREC* record)
 {
     int xfindex, row, col;
     char* data;
     double d;
     data = GetDataOfBREC(record);
     row = Integer2Byte(data[0], data[1]);
     col = Integer2Byte(data[2], data[3]);
     xfindex = Integer2Byte(data[4], data[5]);
 #if defined(__arm__) && !defined(__vfp__)
     d=Double8Byte(data[10], data[11], data[12], data[13],data[6], data[7], data[8], data[9]);
 #else
     d=Double8Byte(data[6], data[7], data[8], data[9],data[10], data[11], data[12], data[13]);
 #endif
     //even if ARM is little endian... doubles are been placed as bigendian words.
     //thanks pb_ for that. :)
     sheet->Set(row,col, CellNumber(row,col,xfindex,d));
     //printf("handleNumber:row=%d,col=%d,val=%f\r\n",row,col,d);
 };
diff --git a/noncore/apps/opie-sheet/mainwindow.cpp b/noncore/apps/opie-sheet/mainwindow.cpp
index 7394623..3095142 100644
--- a/noncore/apps/opie-sheet/mainwindow.cpp
+++ b/noncore/apps/opie-sheet/mainwindow.cpp
@@ -496,533 +496,536 @@ void MainWindow::initMenu()
     addFlyAction(tr("IF(compare,val1,val2)"), tr("IF(compare,val1,val2)"), "IF(", submenuFuncLogic);
     addFlyAction(tr("INDEX(range,index)"),tr("INDEX(range,index)"), "INDEX(", submenuFuncLogic);
     addFlyAction(tr("ISBLANK(x)"), tr("ISBLANK(x)"), "ISBLANK(", submenuFuncLogic);
     addFlyAction(tr("ISNUMBER(x)"), tr("ISNUMBER(x)"), "ISNUMBER(", submenuFuncLogic);
     addFlyAction(tr("EVEN(x)"), tr("EVEN(x)"), "EVEN(", submenuFuncLogic);
     addFlyAction(tr("ISEVEN(x)"), tr("ISEVEN(x)"), "ISEVEN(", submenuFuncLogic);
     addFlyAction(tr("ODD(x)"), tr("ODD(x)"), "ODD(", submenuFuncLogic);
     addFlyAction(tr("ISODD(x)"), tr("ISODD(x)"), "ISODD(", submenuFuncLogic);
     submenuFunc->insertItem(tr("Logical-&Information"), submenuFuncLogic);
 
     submenuFuncTrig=new QPopupMenu;
     addFlyAction(tr("SIN(x)"), tr("SIN(x)"), "SIN(", submenuFuncTrig);
     addFlyAction(tr("COS(x)"), tr("COS(x)"), "COS(", submenuFuncTrig);
     addFlyAction(tr("TAN(x)"), tr("TAN(x)"), "TAN(", submenuFuncTrig);
     addFlyAction(tr("ASIN(x)"), tr("ASIN(x)"), "ASIN(", submenuFuncTrig);
     addFlyAction(tr("ACOS(x)"), tr("ACOS(x)"), "ACOS(", submenuFuncTrig);
     addFlyAction(tr("ATAN(x)"), tr("ATAN(x)"), "ATAN(", submenuFuncTrig);
     addFlyAction(tr("ATAN2(x,y)"), tr("ATAN2(x,y)"), "ATAN2(", submenuFuncTrig);
     submenuFuncTrig->insertSeparator();
     addFlyAction(tr("SINH(x)"), tr("SINH(x)"), "SINH(", submenuFuncTrig);
     addFlyAction(tr("COSH(x)"), tr("COSH(x)"), "COSH(", submenuFuncTrig);
     addFlyAction(tr("TANH(x)"), tr("TANH(x)"), "TANH(", submenuFuncTrig);
     addFlyAction(tr("ACOSH(x)"), tr("ACOSH(x)"), "ACOSH(", submenuFuncTrig);
     addFlyAction(tr("ASINH(x)"), tr("ASINH(x)"), "ASINH(", submenuFuncTrig);
     addFlyAction(tr("ATANH(x)"), tr("ATANH(x)"), "ATANH(", submenuFuncTrig);
     submenuFunc->insertItem(tr("&Trigonometric"), submenuFuncTrig);
 
     submenuFuncString=new QPopupMenu;
     addFlyAction(tr("LEN(s)"), tr("LEN(s)"), "LEN(",submenuFuncString);
     addFlyAction(tr("LEFT(s,num)"), tr("LEFT(s,num)"), "LEFT(",submenuFuncString);
     addFlyAction(tr("RIGHT(s,num)"), tr("RIGHT(s,num)"), "RIGHT(",submenuFuncString);
     addFlyAction(tr("MID(s,pos,len)"), tr("MID(s,pos,len)"), "MID(",submenuFuncString);
     submenuFuncString->insertSeparator();
     addFlyAction(tr("CONCATENATE(s1,s2..)"), tr("CONCATENATE(s1,s2..)"), "CONCATENATE(",submenuFuncString);
     addFlyAction(tr("EXACT(s1,s2)"), tr("EXACT(s1,s2)"), "EXACT(",submenuFuncString);
     addFlyAction(tr("FIND(what,where,pos)"),
                  tr("FIND(what,where,pos)"), "FIND(",submenuFuncString);
     addFlyAction(tr("REPLACE(s,pos,len,ns)"), tr("REPLACE(s,pos,len,ns)"), "REPLACE(",submenuFuncString);
     addFlyAction(tr("REPT(s,n)"), tr("REPT(s,n)"), "REPT(",submenuFuncString);
     submenuFuncString->insertSeparator();
     addFlyAction(tr("UPPER(s)"), tr("UPPER(s)"), "UPPER(",submenuFuncString);
     addFlyAction(tr("LOWER(s)"), tr("LOWER(s)"), "LOWER(",submenuFuncString);
     submenuFunc->insertItem(tr("&Strings"), submenuFuncString);
 
     submenuFuncStat=new QPopupMenu;
     addFlyAction(tr("AVERAGE(range)"), tr("AVERAGE(range)"), "AVERAGE(",submenuFuncStat);
     addFlyAction(tr("COUNT(range)"), tr("COUNT(range)"), "COUNT(",submenuFuncStat);
     addFlyAction(tr("COUNTIF(range,eqls)"), tr("COUNTIF(range,eqls)"), "COUNTIF(",submenuFuncStat);
     addFlyAction(tr("MAX(range)"), tr("MAX(range)"), "MAX(",submenuFuncStat);
     addFlyAction(tr("MIN(range)"), tr("MIN(range)"), "MIN(",submenuFuncStat);
     addFlyAction(tr("SUM(range)"), tr("SUM(range)"), "SUM(",submenuFuncStat);
     addFlyAction(tr("SUMSQ(range)"), tr("SUMSQ(range)"), "SUMSQ(",submenuFuncStat);
     submenuFuncStat->insertSeparator();
     addFlyAction(tr("AVERAGE(range)"), tr("AVERAGE(range)"), "AVERAGE(",submenuFuncStat);
     addFlyAction(tr("VAR(range)"), tr("VAR(range)"), "VAR(",submenuFuncStat);
     addFlyAction(tr("VARP(range)"), tr("VARP(range)"), "VARP(",submenuFuncStat);
     addFlyAction(tr("STDEV(range)"), tr("STDEV(range)"), "STDEV(",submenuFuncStat);
     addFlyAction(tr("STDEVP(range)"), tr("STDEVP(range)"), "STDEVP(",submenuFuncStat);
     addFlyAction(tr("SKEW(range)"), tr("SKEW(range)"), "SKEW(",submenuFuncStat);
     addFlyAction(tr("KURT(range)"), tr("KURT(range)"), "KURT(",submenuFuncStat);
     submenuFunc->insertItem(tr("Sta&tistical"), submenuFuncStat);
 
     submenuFuncScientific=new QPopupMenu;
     addFlyAction(tr("BESSELI(x,n)"), tr("BESSELI(x,n)"), "BESSELI(",submenuFuncScientific);
     addFlyAction(tr("BESSELJ(x,n)"), tr("BESSELJ(x,n)"), "BESSELJ(",submenuFuncScientific);
     addFlyAction(tr("BESSELK(x,n)"), tr("BESSELK(x,n)"), "BESSELK(",submenuFuncScientific);
     addFlyAction(tr("BESSELY(x,n)"), tr("BESSELY(x,n)"), "BESSELY(",submenuFuncScientific);
     submenuFuncScientific->insertSeparator();
     addFlyAction(tr("BETAI(x,a,b)"), tr("BETAI(x,a,b)"), "BETAI(",submenuFuncScientific);
     addFlyAction(tr("ERF(a,b)"), tr("ERF(a,b)"), "ERF(",submenuFuncScientific);
     addFlyAction(tr("ERFC(a,b)"), tr("ERFC(a,b)"), "ERFC(",submenuFuncScientific);
     addFlyAction(tr("GAMMALN(x)"), tr("GAMMALN(x)"), "GAMMALN(",submenuFuncScientific);
     addFlyAction(tr("GAMMAP(x,a)"), tr("GAMMAP(x,a)"), "GAMMAP(",submenuFuncScientific);
     addFlyAction(tr("GAMMAQ(x,a)"), tr("GAMMAQ(x,a)"), "GAMMAQ(",submenuFuncScientific);
     submenuFunc->insertItem(tr("Scienti&fic"), submenuFuncScientific);
 
     submenuFuncDistr=new QPopupMenu;
     addFlyAction(tr("BETADIST(z,a,b,Q?)"), tr("BETADIST(z,a,b,Q?)"), "BETADIST(",submenuFuncDistr);
     addFlyAction(tr("CHI2DIST(x,n,Q?)"), tr("CHI2DIST(x,n,Q?)"), "CHI2DIST(",submenuFuncDistr);
     addFlyAction(tr("CHIDIST(x,n,Q?)"), tr("CHIDIST(x,n,Q?)"), "CHIDIST(",submenuFuncDistr);
     addFlyAction(tr("FDIST(z,deg1,deg2,Q?)"), tr("FDIST(z,deg1,deg2,Q?)"), "FDIST(",submenuFuncDistr);
     addFlyAction(tr("GAMMADIST(x,a,b,Q?)"), tr("GAMMADIST(x,a,b,Q?)"), "GAMMADIST(",submenuFuncDistr);
     addFlyAction(tr("NORMALDIST(x,m,s,Q?)"), tr("NORMALDIST(x,m,s,Q?)"), "NORMALDIST(",submenuFuncDistr);
     addFlyAction(tr("PHI(x,Q?)"), tr("PHI(x,Q?)"), "PHI(",submenuFuncDistr);
     addFlyAction(tr("POISSON(x,n,Q?)"), tr("POISSON(x,n,Q?)"), "POISSON(",submenuFuncDistr);
     submenuFunc->insertItem(tr("&Distributions"), submenuFuncDistr);
 
 
 
     menuInsert->insertSeparator();
     insertCells->addTo(menuInsert);
     insertRows->addTo(menuInsert);
     insertCols->addTo(menuInsert);
     insertSheets->addTo(menuInsert);
 }
 
 void MainWindow::initStandardToolbar()
 {
     toolbarStandard=new QToolBar(this);
     toolbarStandard->setHorizontalStretchable(TRUE);
     moveToolBar(toolbarStandard, Top);
 
     fileNew->addTo(toolbarStandard);
     fileOpen->addTo(toolbarStandard);
     fileSave->addTo(toolbarStandard);
 
     comboSheets=new QComboBox(toolbarStandard);
     toolbarStandard->setStretchableWidget(comboSheets);
     connect(comboSheets, SIGNAL(activated(const QString&)), this, SLOT(slotSheetChanged(const QString&)));
 }
 
 void MainWindow::initFunctionsToolbar()
 {
     toolbarFunctions=new QToolBar(this);
     toolbarFunctions->setHorizontalStretchable(TRUE);
     moveToolBar(toolbarFunctions, Bottom);
 
     funcEqual->addTo(toolbarFunctions);
     funcPlus->addTo(toolbarFunctions);
     funcMinus->addTo(toolbarFunctions);
     funcCross->addTo(toolbarFunctions);
     funcDivide->addTo(toolbarFunctions);
     funcParanOpen->addTo(toolbarFunctions);
     funcParanClose->addTo(toolbarFunctions);
     funcComma->addTo(toolbarFunctions);
 
     toolFunction=new QToolButton(toolbarFunctions);
     toolFunction->setPixmap(Resource::loadPixmap( "opie-sheet/func-func" ));
     toolFunction->setTextLabel(tr("Functions"));
     toolFunction->setPopup(submenuFunc);
     toolFunction->setPopupDelay(0);
 }
 
 void MainWindow::initEditToolbar()
 {
     toolbarEdit=new QToolBar(this);
     toolbarEdit->setHorizontalStretchable(TRUE);
     moveToolBar(toolbarEdit, Bottom);
 
     editAccept->addTo(toolbarEdit);
     editCancel->addTo(toolbarEdit);
 
     editData=new QLineEdit(toolbarEdit);
     toolbarEdit->setStretchableWidget(editData);
     connect(editData, SIGNAL(returnPressed()), this, SLOT(slotEditAccept()));
 
     editCellSelect->addTo(toolbarEdit);
 }
 
 void MainWindow::slotHelpAbout()
 {
     QDialog dialogAbout(this, 0, TRUE);
     dialogAbout.resize(width()-40, height()-80);
     dialogAbout.setCaption(tr("About Opie Sheet"));
 
     QLabel label(tr("Opie Sheet\nSpreadsheet Software for Opie\nQWDC Beta Winner (as Sheet/Qt)\n\nDeveloped by: Serdar Ozler\nRelease 1.0.2\nRelease Date: October 08, 2002\n\nThis product is licensed under GPL. It is freely distributable. If you want to get the latest version and also the source code, please visit the web site.\n\nhttp://qtopia.sitebest.com"), &dialogAbout);
     label.setGeometry(dialogAbout.rect());
     label.setAlignment(Qt::AlignCenter | Qt::WordBreak);
 
     dialogAbout.exec();
 }
 
 void MainWindow::initSheet()
 {
     sheet=new Sheet(DEFAULT_NUM_ROWS, DEFAULT_NUM_COLS, this);
     setCentralWidget(sheet);
 
     connect(sheet, SIGNAL(currentDataChanged(const QString&)), editData, SLOT(setText(const QString&)));
     connect(sheet, SIGNAL(cellClicked(const QString&)), this, SLOT(slotCellClicked(const QString&)));
     connect(sheet, SIGNAL(sheetModified()), this, SLOT(slotDocModified()));
 
     connect(editCut, SIGNAL(activated()), sheet, SLOT(editCut()));
     connect(editCopy, SIGNAL(activated()), sheet, SLOT(editCopy()));
     connect(editClear, SIGNAL(activated()), sheet, SLOT(editClear()));
 }
 
 void MainWindow::slotEditAccept()
 {
     sheet->setData(editData->text());
 }
 
 void MainWindow::slotEditCancel()
 {
     editData->setText(sheet->getData());
 }
 
 void MainWindow::slotCellSelect(bool lock)
 {
     sheet->lockClicks(lock);
 }
 
 void MainWindow::addToData(const QString &data)
 {
     editData->setText(editData->text().insert(editData->cursorPosition(), data));
 }
 
 void MainWindow::slotFuncOutput()
 {
     if (sender()->isA("QAction"))
         addToData(((QAction *)sender())->toolTip());
 }
 
 void MainWindow::slotInsertRows()
 {
     NumberDialog dialogNumber(this);
     if (dialogNumber.exec(tr("Insert Rows"), tr("&Number of rows:"))==QDialog::Accepted)
         sheet->insertRows(dialogNumber.getValue());
 }
 
 void MainWindow::slotInsertCols()
 {
     NumberDialog dialogNumber(this);
     if (dialogNumber.exec(tr("Insert Columns"), tr("&Number of columns:"))==QDialog::Accepted)
         sheet->insertColumns(dialogNumber.getValue());
 }
 
 void MainWindow::slotInsertSheets()
 {
     NumberDialog dialogNumber(this);
     if (dialogNumber.exec(tr("Add Sheets"), tr("&Number of sheets:"))==QDialog::Accepted)
         for (int i=dialogNumber.getValue(); i>0; --i) createNewSheet();
 }
 
 void MainWindow::slotCellClicked(const QString &cell)
 {
     editCellSelect->setOn(FALSE);
     addToData(cell);
 }
 
 typeSheet *MainWindow::createNewSheet()
 {
     typeSheet *newSheet=new typeSheet;
     int currentNo=1, tempNo=0;
     bool ok;
 
     for (typeSheet *tempSheet=listSheets.first(); tempSheet; tempSheet=listSheets.next())
         if (tempSheet->name.startsWith(tr("Sheet")) && (tempNo=tempSheet->name.mid(tr("Sheet").length()).toInt(&ok))>=currentNo && ok)
             currentNo=tempNo+1;
 
     newSheet->name=tr("Sheet")+QString::number(currentNo);
     newSheet->data.setAutoDelete(TRUE);
 
     comboSheets->insertItem(newSheet->name);
     listSheets.append(newSheet);
     return newSheet;
 }
 
 typeSheet *MainWindow::findSheet(const QString &name)
 {
     for (typeSheet *tempSheet=listSheets.first(); tempSheet; tempSheet=listSheets.next())
         if (tempSheet->name==name)
             return tempSheet;
     return NULL;
 }
 
 void MainWindow::slotSheetChanged(const QString &name)
 {
     sheet->copySheetData(&findSheet(sheet->getName())->data);
     sheet->setName(name);
     sheet->setSheetData(&findSheet(name)->data);
     sheet->ReCalc();
 }
 
 void MainWindow::addFlyAction(const QString &text, const QString &menuText, const QString &tip, QWidget *w)
 {
     QAction *action=new QAction(text, menuText, 0, this);
     action->setToolTip(tip);
     connect(action, SIGNAL(activated()), this, SLOT(slotFuncOutput()));
     action->addTo(w);
 }
 
 void MainWindow::slotFormatCells()
 {
     CellFormat dialogCellFormat(this);
     QPEApplication::showDialog( &dialogCellFormat );
     dialogCellFormat.exec(sheet);
 }
 
 void MainWindow::slotEditPaste()
 {
     sheet->editPaste();
 }
 
 void MainWindow::slotEditPasteContents()
 {
     sheet->editPaste(TRUE);
 }
 
 void MainWindow::slotRowHeight()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     NumberDialog dialogNumber(this);
     if (dialogNumber.exec(tr("Row Height"), tr("&Height of each row:"), sheet->rowHeight(row1))==QDialog::Accepted)
     {
         int newHeight=dialogNumber.getValue(), row;
         for (row=row1; row<=row2; ++row)
             sheet->setRowHeight(row, newHeight);
     }
 }
 
 void MainWindow::slotRowAdjust()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int row=row1; row<=row2; ++row)
         sheet->adjustRow(row);
 }
 
 void MainWindow::slotRowShow()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int row=row1; row<=row2; ++row)
         sheet->showRow(row);
 }
 
 void MainWindow::slotRowHide()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int row=row1; row<=row2; ++row)
         sheet->hideRow(row);
 }
 
 void MainWindow::slotColumnWidth()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     NumberDialog dialogNumber(this);
     if (dialogNumber.exec(tr("Column Width"), tr("&Width of each column:"), sheet->columnWidth(col1))==QDialog::Accepted)
     {
         int newWidth=dialogNumber.getValue(), col;
         for (col=col1; col<=col2; ++col)
             sheet->setColumnWidth(col, newWidth);
     }
 }
 
 void MainWindow::slotColumnAdjust()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int col=col1; col<=col2; ++col)
         sheet->adjustColumn(col);
 }
 
 void MainWindow::slotColumnShow()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int col=col1; col<=col2; ++col)
         sheet->showColumn(col);
 }
 
 void MainWindow::slotColumnHide()
 {
     int row1, row2, col1, col2;
     sheet->getSelection(&row1, &col1, &row2, &col2);
 
     for (int col=col1; col<=col2; ++col)
         sheet->hideColumn(col);
 }
 
 void MainWindow::slotFileSaveAs()
 {
     TextDialog dialogText(this);
     if (dialogText.exec(tr("Save File As"), tr("&File Name:"), currentDoc->name())!=QDialog::Accepted || dialogText.getValue().isEmpty()) return;
 
     currentDoc->setName(dialogText.getValue());
     currentDoc->setFile(QString::null);
     currentDoc->setLinkFile(QString::null);
     documentSave(currentDoc);
 }
 
 void MainWindow::slotImportExcel(const DocLnk &lnkDoc)
 {
     ExcelBook file1;
-    file1.ParseBook((char *)lnkDoc.file().ascii());
+    if ( !file1.ParseBook((char *)lnkDoc.file().ascii()) ){
+	    QMessageBox::critical(this, tr("Error"), tr("<td>Unable to open or parse file!</td>"));
+	    return;
+    }
     int NumOfSheets=file1.Sheets.count();
     printf("OpieSheet::NumberOfSheets:%d\r\n",NumOfSheets);
     if (documentModified && saveCurrentFile()==QMessageBox::Cancel) return;
     if (currentDoc) delete currentDoc;
     currentDoc = new DocLnk();
     listSheets.clear();
     comboSheets->clear();
     int w1,r,c;
     ExcelSheet* sh1;
     typeSheet* newSheet;
     QString* str;
     typeCellData* newCell;
     for(w1=1;w1<=NumOfSheets;w1++)
     {
         sh1=file1.Sheets[w1-1];
-        printf("OpieSheet:newSheet:%x,r=%d,c=%d\r\n",sh1,sh1->rows,sh1->cols);
+        // printf("OpieSheet:newSheet:%x,r=%d,c=%d\r\n",sh1, sh1->rows,sh1->cols);
         newSheet=new typeSheet;
         newSheet->data.setAutoDelete(TRUE);
         newSheet->name=sh1->name;
         printf("OpieSheet:Sheetname:%s\r\n",sh1->name.ascii());
         comboSheets->insertItem(newSheet->name);
         for(r=1; r <= sh1->rows; r++)
         {
             for(c=1;c <= sh1->cols; c++)
             {
                 str=file1.CellDataString(sh1,r-1,c-1);
                 if(str!=NULL && r<DEFAULT_NUM_ROWS && c<DEFAULT_NUM_COLS)
                 {
                     newCell=new typeCellData;
                     newCell->row=r-1;
                     newCell->col=c-1;
                     if(str!=NULL) newCell->data=QString(*str); else newCell->data=QString("");
                     newCell->background=QBrush(Qt::white, Qt::SolidPattern);
                     newCell->alignment=(Qt::AlignmentFlags)(Qt::AlignLeft | Qt::AlignTop);
                     newCell->fontColor=Qt::black;
                     newCell->font=font();
                     newCell->borders.right=QPen(Qt::gray, 1, Qt::SolidLine);
                     newCell->borders.bottom=QPen(Qt::gray, 1, Qt::SolidLine);
                     newSheet->data.append(newCell);
                     //there is no format parsing at the moment or style parsing
                     //printf("OpieSheetNumber:row=%d,col=%d,val=%s\r\n",r,c,str->latin1());
                 };
             };
         };
         listSheets.append(newSheet);
         if (w1==1)//if i==0 link sheet1 with sheetview
         {
             sheet->setName(newSheet->name);
             sheet->setSheetData(&newSheet->data);
             sheet->ReCalc();
         };
 
     };
     file1.CloseFile();
     printf("Excel FILE read OK\r\n");
     documentModified=TRUE;
 
 
 }
 
 void MainWindow::slotSheetRename()
 {
     TextDialog dialogText(this);
     if (dialogText.exec(tr("Rename Sheet"), tr("&Sheet Name:"), sheet->getName())!=QDialog::Accepted || dialogText.getValue().isEmpty()) return;
     QString newName=dialogText.getValue();
 
     typeSheet *tempSheet=findSheet(newName);
     if (tempSheet)
     {
         QMessageBox::critical(this, tr("Error"), tr("There is already a sheet named '"+newName+'\''));
         return;
     }
 
     tempSheet=findSheet(sheet->getName());
     for (int i=0; i<comboSheets->count(); ++i)
         if (comboSheets->text(i)==tempSheet->name)
         {
             comboSheets->changeItem(newName, i);
             break;
         }
     tempSheet->name=newName;
     sheet->setName(newName);
 }
 
 void MainWindow::slotSheetRemove()
 {
     if (comboSheets->count()<2)
     {
         QMessageBox::warning(this, tr("Error"), tr("There is only one sheet!"));
         return;
     }
     if (QMessageBox::information(this, tr("Remove Sheet"), tr("Are you sure?"), QMessageBox::Yes, QMessageBox::No)==QMessageBox::Yes)
     {
         typeSheet *tempSheet=findSheet(sheet->getName());
         for (int i=0; i<comboSheets->count(); ++i)
             if (comboSheets->text(i)==tempSheet->name)
             {
                 comboSheets->removeItem(i);
                 break;
             }
         comboSheets->setCurrentItem(0);
         slotSheetChanged(comboSheets->currentText());
         listSheets.remove(tempSheet);
     }
 }
 
 void MainWindow::slotDataSort()
 {
     SortDialog dialogSort(this);
     QPEApplication::showDialog( &dialogSort );
     dialogSort.exec(sheet);
 }
 
 void MainWindow::slotDocModified()
 {
     documentModified=TRUE;
 }
 
 void MainWindow::slotInsertCells()
 {
     QDialog dialogInsert(this, 0, TRUE);
     dialogInsert.resize(180, 130);
     dialogInsert.setCaption(tr("Insert Cells"));
 
     QVButtonGroup *group=new QVButtonGroup(tr("&Type"), &dialogInsert);
     group->setGeometry(10, 10, 160, 110);
     QRadioButton *radio=new QRadioButton(tr("Shift cells &down"), group);
     radio=new QRadioButton(tr("Shift cells &right"), group);
     radio=new QRadioButton(tr("Entire ro&w"), group);
     radio=new QRadioButton(tr("Entire &column"), group);
     group->setButton(0);
 
     if (dialogInsert.exec()==QDialog::Accepted)
         switch (group->id(group->selected()))
         {
         case 0: sheet->insertRows(1, FALSE); break;
         case 1: sheet->insertColumns(1, FALSE); break;
         case 2: sheet->insertRows(1, TRUE); break;
         case 3: sheet->insertColumns(1, TRUE); break;
         }
 }
 
 void MainWindow::slotDataFindReplace()
 {
     FindDialog dialogFind(this);
     QPEApplication::showDialog( &dialogFind );
     dialogFind.exec(sheet);
 }