textarea.cpp

00001 /***************************************************************************
00002                           textarea.cpp  -  description
00003                              -------------------
00004     begin                : Mon Mar 1 2004
00005     copyright            : (C) 2004 by Dynacube Team
00006     email                :
00007  ***************************************************************************/
00008 
00009 /***************************************************************************
00010  *                                                                         *
00011  *   This program is free software; you can redistribute it and/or modify  *
00012  *   it under the terms of the GNU General Public License as published by  *
00013  *   the Free Software Foundation; either version 2 of the License, or     *
00014  *   (at your option) any later version.                                   *
00015  *                                                                         *
00016  ***************************************************************************/
00017  #include "gui/components/textarea.h"
00018 
00019 
00020  void textarea::textarea_init(DW _id,DW _parent_id,DW _cnt_type,void *_cnt_ptr,DW _alias_id,DW _x,DW _y,DW _width,DW _height,DD _style,char *_txt)
00021  {
00022     DW i,k,rows;
00023     DW num_chars;
00024     memcpy(txt,_txt,strlen(_txt));
00025     comp_init(TEXTAREA_TYPE,_id,_parent_id,_cnt_type,_cnt_ptr,_alias_id,_x,_y,_width,_height,_style);
00026     rows = 0;
00027     cur_x = 0;
00028     cur_y = 0;
00029     st_row = 0;
00030     st_col = 0;
00031     num_chars = strlen(_txt);
00032     visi_rows = (height/(CHAR_HEIGHT+Y_OFFSET)) - 1;
00033     visi_cols = (width/(CHAR_WIDTH+X_OFFSET)) - 1;
00034     for(k=0,i=0;i<num_chars;i++)
00035       {
00036         if(_txt[i] == '\n')
00037          {
00038            txt[rows][k] = '\0';
00039            k = 0;
00040            rows++;
00041          }
00042         else
00043          {
00044          txt[rows][k] = _txt[i];
00045          k++;
00046          }
00047   }
00048         if(k != 0)
00049           txt[rows][k] = '\0';
00050   max_row = rows + 1;
00051 
00052     is_sel = false;
00053     sel_stx = 0;
00054     sel_sty = 0;
00055     sel_enx = 0;
00056     sel_eny = 0;
00057  }
00058 
00059  void textarea::paint()
00060   {
00061     window *win_ptr;
00062     frame *frm_ptr;
00063     DW _x,_y,_width,_height;
00064     DW i,j,k;
00065     char tmp[255];
00066 
00067     switch(cnt_type)
00068     {
00069       case WIND_TYPE :
00070                       win_ptr = (window *) cnt_ptr;
00071                       if(win_ptr->style & W_MAXIMIZE)
00072                        {
00073                          _x = BORDER_WIDTH;
00074                          _y = TITLE_HEIGHT + BORDER_HEIGHT + ((win_ptr->hasMenu) ? MENUBAR_HEIGHT : 0);
00075                          _width  = SCREEN_WIDTH;
00076                          _height = SCREEN_HEIGHT;
00077                        }
00078                       else
00079                        {
00080                          _x = win_ptr->x + BORDER_WIDTH;
00081                          _y = win_ptr->y + TITLE_HEIGHT + BORDER_HEIGHT + ((win_ptr->hasMenu) ? MENUBAR_HEIGHT : 0);
00082                          _width = win_ptr->width;
00083                          _height = win_ptr->height;
00084                        }
00085 
00086                       if((x + width < _width) && (y + height < _height))
00087                       {
00088 /*                         rect(30,30,100,100);
00089                                                    ginfo(50,30,itoa(cur_x,10));
00090                                                  ginfo(70,30,itoa(cur_y,10));*/
00091 
00092                          fillrect(x+_x, y+_y, width, height,TEXT_COLOR);
00093                                          if(is_sel)
00094                           {
00095 /*                                                          ginfo(50,50,itoa(sel_stx,10));
00096                                                           ginfo(70,50,itoa(sel_sty,10));
00097                                                           ginfo(50,70,itoa(sel_enx,10));
00098                                                           ginfo(70,70,itoa(sel_eny,10)); */
00099 
00100                            //same line case                       
00101                            if(sel_sty == sel_eny)
00102                             {
00103                              if(sel_stx >=st_col && sel_stx <= st_col + visi_cols)
00104                                     {
00105                                              if(sel_enx <= st_col + visi_cols)
00106                                                          fillrect(x+_x + X_OFFSET + (sel_stx - st_col) * 7,y + _y + Y_OFFSET +(sel_sty - st_row) *9,(sel_enx - sel_stx) * 7,9,0x3E0);
00107                                      else
00108                                                          fillrect(x+_x + X_OFFSET + (sel_stx - st_col) * 7,y + _y + Y_OFFSET+(sel_sty - st_row) *9,(visi_cols + st_col - sel_stx) * 7,9,0xE300);
00109                                     }
00110                                            else if(sel_enx >=st_col && sel_enx <= st_col + visi_cols)
00111                                             {
00112                                                  fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (st_row + sel_sty) *9,(sel_enx - st_col) * 7,9,0x1F);
00113                                             }
00114                             }                            
00115                            else
00116                            {
00117                            //start is in the visible portion
00118                                            if(sel_sty >=st_row && sel_sty <= st_row + visi_rows)
00119                                             {
00120                               if(sel_stx >=st_col && sel_stx <= st_col + visi_cols)
00121                                  fillrect(x+_x + X_OFFSET + (sel_stx - st_col) * 7,y + _y + Y_OFFSET  + (sel_sty - st_row) *9,(visi_cols + st_col - sel_stx) * 7,9,0x3E0);
00122                               else if(sel_stx < st_col)
00123                                  fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (sel_sty - st_row) *9,visi_cols * 7,9,0x3E0);
00124 
00125                                                 for(i = sel_sty+1;i < sel_eny && i <= st_row + visi_rows;i++)
00126                                                   fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (i - st_row) *9,visi_cols * 7,9,0x3E0);
00127 
00128                             if(sel_eny <= st_row + visi_rows)
00129                              {
00130                               if(sel_enx >=st_col && sel_enx <= st_col + visi_cols)
00131                                 fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (sel_eny - st_row) *9,(sel_enx - st_col) * 7,9,0x3E0);
00132                               else if(sel_enx > st_col)
00133                                  fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (sel_eny - st_row) *9,visi_cols * 7,9,0x3E0);
00134                              }
00135                                             }
00136                             //end is in the visible portion
00137                                            else if(sel_eny >=st_row && sel_eny <= st_row + visi_rows)
00138                                     {
00139                                                 for(i = st_row;i < sel_eny ;i++)
00140                                                   fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (i - st_row) *9,visi_cols * 7,9,0x3E0);
00141   
00142                             if(sel_enx >=st_col && sel_enx <= st_col + visi_cols)
00143                                 fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (sel_eny - st_row) *9,(sel_enx - st_col) * 7,9,0x3E0);
00144                             else if(sel_enx > st_col)
00145                                  fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (sel_eny - st_row) *9,visi_cols * 7,9,0x3E0);
00146                                     }
00147                            //both are not. but visible is selected                           
00148                            else if(sel_eny >=st_row)
00149                             {
00150                             for(i = st_row;i <= st_row + visi_rows;i++)
00151                                                   fillrect(x+_x + X_OFFSET,y + _y + Y_OFFSET + (i - st_row) *9,visi_cols * 7,9,0x3E0);                              
00152                             }
00153                            } 
00154                                             }//selection
00155 
00156                          for(j=st_row;j<=st_row+visi_rows && j < max_row;j++)
00157                           {
00158                             drawstring(x+_x+X_OFFSET,y+_y+Y_OFFSET+(j-st_row)*9,(char *)strmncpy( (void *)tmp,(void *)txt[j],st_col,visi_cols));
00159                           }
00160 //                         drawstring(x+_x+5,y+_y+5,txt);
00161                          emboss3D(x+_x, y+_y, width, height,0,_true,1);
00162                       }
00163                       else
00164                       {
00165                          rect(x+_x, y+_y, width, height);
00166                          drawstring(x+_x+5,y+_y+5,tmp);
00167                          emboss3D(x+_x, y+_y, width, height,0,_true,1);
00168                       }
00169                       break;
00170 //      case FRM_TYPE :
00171 //                      frm_ptr = (frame *) cnt_ptr;
00172 //                      if((x + width <  frm_ptr->width) && (y + height < frm_ptr->height))
00173 //                         rect(x+frm_ptr->x,y+frm_ptr->y,width,height);
00174 
00175     }
00176   }
00177    void textarea::updateCursor()
00178    {
00179      POINT pt;
00180 
00181      pt = getAbsLoc(this);
00182 
00183      if(cur_x > st_col + visi_cols)
00184         st_col = cur_x - visi_cols;
00185      if(cur_x < st_col)
00186         st_col = cur_x;
00187 
00188      if(cur_y > st_row + visi_rows)
00189         st_row = cur_y - visi_rows;
00190      if(cur_y < st_row)
00191         st_row = cur_y;
00192 
00193      pt.x += (DW)((cur_x - st_col)*7) - 1;
00194      pt.y += (DW)((cur_y - st_row)*9) - 1;
00195      pt.x += X_OFFSET;
00196      pt.y += Y_OFFSET;
00197      csr.setCursor(pt);
00198      csr.show();
00199    }
00200    
00201    void textarea::react(DW _x,DW _y)
00202    {
00203     POINT pt;
00204     DW row,col;
00205 
00206     pt = getAbsLoc(this);
00207     col = (_x - pt.x - X_OFFSET) / 7;
00208     row = (_y - pt.y - Y_OFFSET) / 9;
00209     is_sel = false;
00210 
00211     if((row + st_row) < max_row)
00212        cur_y = row + st_row;
00213     else
00214        cur_y = max_row -1;
00215 
00216     if((col + st_col) <= strlen(txt[cur_y]))
00217              cur_x = col + st_col;
00218     else
00219            cur_x = strlen(txt[cur_y]);
00220     updateCursor();
00221    }
00222 
00223    void textarea::keyPress(DW state,DW ch)
00224    {
00225      DW i,j;
00226      char tmp,tmp1;
00227      DW prev_cur_x,prev_cur_y;
00228      POINT pt;
00229      DW total_chars,num_lines,len;
00230      pt = getAbsLoc(this);
00231      prev_cur_x = cur_x;
00232      prev_cur_y = cur_y;
00233 
00234     if(state & ST_ALT)
00235       return;
00236     if(state & ST_CAPS)
00237         ch = toupper(ch);
00238 
00239      if(state & ST_SHIFT)
00240         ch = toggle_shift(ch);
00241     if(state & ST_CNTL)
00242     {
00243       switch(ch)
00244        {
00245          case 'c' :
00246                             if(is_sel)
00247                                 {
00248                                  copy();
00249                                 }
00250                             break;
00251          case 'x' :
00252                     if(is_sel)
00253                                 {
00254                                   cut();
00255                         }
00256                             break;
00257          case 'v' :
00258                     if(cl_pres)
00259                          {
00260                                 paste();
00261                                 is_sel = false;
00262                          }
00263                     break;
00264          case HOME      :
00265                                  cur_x = 0;
00266                                  cur_y = 0;
00267                                  updateCursor();
00268                      if(!(state & ST_SHIFT))
00269                        {
00270                                   is_sel = false;
00271                        }
00272                     else
00273                        {
00274                         if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00275                           return;
00276                                         if(is_sel)
00277                                         {
00278                          switch(ptcmp(cur_x,cur_y,sel_stx,sel_sty))
00279                           {
00280                            case 1:
00281                                              sel_enx = cur_x;
00282                                              sel_eny = cur_y;
00283                                 break;
00284                            case -1:
00285                                 sel_stx = cur_x;
00286                                       sel_sty = cur_y;
00287                                 break;
00288                            case 0:
00289                                 is_sel = false;
00290                                 break;
00291                           }
00292                                   }
00293                                          else
00294                                           {
00295                            is_sel = true;
00296                                            sel_stx = cur_x;
00297                                            sel_sty = cur_y;
00298                                    sel_enx = prev_cur_x;
00299                                        sel_eny = prev_cur_y;
00300                                           }
00301                        }
00302                                  restoreImage(mcurx,mcury);
00303                                  paint();
00304                                  if(mouse_inited)
00305                                    {
00306                                   getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
00307                                  }
00308                                  mvMini2Svga(pt.x,pt.y,width,height);
00309                                  break;
00310         case END        :
00311                          cur_y = max_row-1;
00312                                cur_x = strlen(txt[cur_y]);
00313                          updateCursor();
00314              if(!(state & ST_SHIFT))
00315              {
00316                           is_sel = false;
00317              }
00318             else
00319              {
00320                if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00321                  return;
00322                          if(is_sel)
00323                                   {
00324                      switch(ptcmp(cur_x,cur_y,sel_enx,sel_eny))
00325                       {
00326                         case 1:
00327                                              sel_enx = cur_x;
00328                                              sel_eny = cur_y;
00329                                 break;
00330                         case -1:
00331                                 sel_stx = cur_x;
00332                                       sel_sty = cur_y;
00333                                 break;
00334                         case 0:
00335                                 is_sel = false;
00336                                 break;
00337                       }
00338                      }
00339                                  else
00340                                   {
00341                    is_sel = true;
00342                                    sel_enx = cur_x;
00343                                    sel_eny = cur_y;
00344                                    sel_stx = prev_cur_x;
00345                                    sel_sty = prev_cur_y;
00346                                     }
00347              }
00348                          restoreImage(mcurx,mcury);
00349                          paint();
00350                          if(mouse_inited)
00351                            {
00352                           getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
00353                          }
00354                          mvMini2Svga(pt.x,pt.y,width,height);
00355              break;
00356        }
00357       return;
00358     }
00359 
00360     if(ch > ESC)
00361      {
00362      if(!(state & ST_SHIFT))
00363      {
00364       switch(ch)
00365        {
00366         case DEL        :
00367                     if(!is_sel)
00368                     {
00369                                  total_chars = strlen(txt[cur_y]);
00370                            if(cur_x < total_chars)
00371                                   {
00372                                    for(i=cur_x;i<total_chars - 1;i++)
00373                                      txt[cur_y][i] = txt[cur_y][i+1];
00374                                    txt[cur_y][total_chars-1] = '\0';
00375                                   }
00376                            else
00377                                   {
00378                                    if(cur_y == max_row - 1)
00379                                     return;
00380                                    strcat(txt[cur_y],txt[cur_y+1]);
00381 
00382                                    for(i=cur_y +1;i<max_row - 1;i++)
00383                                             strcpy(txt[i],txt[i+1]);
00384 
00385                        strcpy(txt[i],"");
00386                                    max_row--;
00387                                   }
00388                                  if(cur_x > strlen(txt[cur_y]))
00389                                         cur_x = strlen(txt[cur_y]);
00390                     }
00391                 else
00392                 {
00393                  num_lines = sel_eny - sel_sty;
00394                  if(num_lines == 0)
00395                  {
00396                   len =  sel_enx - sel_stx;
00397                         total_chars = strlen(txt[sel_sty]);
00398 
00399                   for(i = sel_stx;i<total_chars;i++)
00400                       txt[sel_sty][i] = txt[sel_sty][i + len];
00401 
00402                   total_chars -= len;
00403                   txt[sel_sty][total_chars] = '\0';
00404                  }
00405                  else
00406                   {
00407                     for(i = sel_enx; i < strlen(txt[sel_eny]) ; i++)
00408                        txt[sel_sty][sel_stx + i - sel_enx] =txt[sel_eny][i];
00409 
00410                     txt[sel_sty][sel_stx + i - sel_enx] = '\0';
00411 
00412                     for(i = sel_sty + 1; i < max_row ;i++)
00413                       strcpy(txt[i],txt[i+num_lines]);
00414                     max_row -= num_lines;
00415                   }
00416                   cur_x = sel_stx;
00417                   cur_y = sel_sty;
00418                   updateCursor();
00419                 }
00420                          break;
00421         case LEFT_A     :
00422                          if(cur_x > 0)
00423                          {
00424                          cur_x--;
00425                          updateCursor();
00426                          }
00427                          else if(cur_y > 0)
00428                           {
00429                            cur_y--;
00430                            cur_x = strlen(txt[cur_y]);
00431                            updateCursor();
00432                           }
00433                          break;
00434         case RIGHT_A    :
00435                          if(cur_x < strlen(txt[cur_y]))
00436                          {
00437                           cur_x++;
00438                           updateCursor();
00439                          }
00440                          else if(cur_y < max_row -1)
00441                          {
00442                            cur_y++;
00443                            cur_x = 0;
00444                            updateCursor();
00445                          }
00446                          break;
00447         case UP         :
00448                          if(cur_y > 0)
00449                           {
00450                            cur_y--;
00451                            if(cur_x > strlen(txt[cur_y]))
00452                                 cur_x = strlen(txt[cur_y]);
00453                            updateCursor();
00454                           }
00455                          break;
00456         case DOWN       :
00457                          if(cur_y < max_row -1)
00458                           {
00459                            cur_y++;
00460                            if(cur_x > strlen(txt[cur_y]))
00461                                 cur_x = strlen(txt[cur_y]);
00462                            updateCursor();
00463                           }
00464                          break;
00465         case HOME       :
00466                          cur_x = 0;
00467                          updateCursor();
00468                          break;
00469         case END        :
00470                          cur_x = strlen(txt[cur_y]);
00471                          updateCursor();
00472                          break;
00473         case PAGE_UP    :
00474                          if(st_row - visi_rows >= 0)
00475                          {
00476                            st_row -= visi_rows - 1;
00477                            cur_y  -= visi_rows;
00478                          }
00479                          else
00480                          {
00481                             cur_y = 0;
00482                             st_row = 0;
00483                          }
00484 
00485                          if(cur_x > strlen(txt[cur_y]))
00486                                  cur_x = strlen(txt[cur_y]);
00487                          break;
00488         case PAGE_DOWN  :
00489                         if(st_row + visi_rows < max_row)
00490                         {
00491                            st_row += visi_rows - 1;
00492                            if(cur_y + visi_rows < max_row)
00493                              cur_y  += visi_rows;
00494                            else
00495                              cur_y = max_row - 1;
00496                         }
00497                         else
00498                          {
00499                               cur_y = max_row - 1;
00500                          }
00501                          if(cur_x > strlen(txt[cur_y]))
00502                                 cur_x = strlen(txt[cur_y]);
00503                          break;
00504    }
00505     is_sel = false;
00506   }
00507     else
00508      {
00509       switch(ch)
00510        {
00511         case LEFT_A     :
00512                                  if(cur_x > 0)
00513                                  {
00514                                  cur_x--;
00515                                  updateCursor();
00516                                  }
00517                          else if(cur_y > 0)
00518                           {
00519                                    cur_y--;
00520                            cur_x = strlen(txt[cur_y]);
00521                                    updateCursor();
00522                                   }
00523                    if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00524                     return;
00525                                  if(is_sel)
00526                                     {
00527                      switch(ptcmp(cur_x,cur_y,sel_stx,sel_sty))
00528                       {
00529                         case 1:
00530                                              sel_enx = cur_x;
00531                                              sel_eny = cur_y;
00532                                 break;
00533                         case -1:
00534                                 sel_stx = cur_x;
00535                                       sel_sty = cur_y;
00536                                 break;
00537                         case 0:
00538                                 is_sel = false;
00539                                 break;
00540                       }   
00541                           }
00542                                  else
00543                                   {
00544                            is_sel = true;
00545                                    sel_stx = cur_x;
00546                                    sel_sty = cur_y;
00547                                    sel_enx = prev_cur_x;                
00548                                    sel_eny = prev_cur_y;
00549                                   }
00550                                  break;
00551         case RIGHT_A    :
00552                                  if(cur_x < strlen(txt[cur_y]))
00553                          {
00554                           cur_x++;
00555                           updateCursor();
00556                              }
00557                          else if(cur_y < max_row -1)
00558                                  {
00559                            cur_y++;
00560                            cur_x = 0;
00561                            updateCursor();
00562                            }
00563                 if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00564                   return;
00565                                  if(is_sel)
00566                                   {
00567                      switch(ptcmp(cur_x,cur_y,sel_enx,sel_eny))
00568                       {
00569                         case 1:
00570                                              sel_enx = cur_x;
00571                                              sel_eny = cur_y;
00572                                 break;
00573                         case -1:
00574                                 sel_stx = cur_x;
00575                                       sel_sty = cur_y;
00576                                 break;
00577                         case 0:
00578                                 is_sel = false;
00579                                 break;
00580                       }   
00581                      }
00582                                  else
00583                                   {
00584                    is_sel = true;
00585                                    sel_enx = cur_x;
00586                                    sel_eny = cur_y;
00587                                    sel_stx = prev_cur_x;
00588                                    sel_sty = prev_cur_y;
00589                                     }
00590            
00591                                   break;
00592   case UP :
00593                  if(cur_y > 0)
00594                           {
00595                                  cur_y--;
00596                                if(cur_x > strlen(txt[cur_y]))
00597                                         cur_x = strlen(txt[cur_y]);
00598                                updateCursor();
00599                           }
00600                    if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00601                     return;
00602                                  if(is_sel)
00603                                     {
00604                      switch(ptcmp(cur_x,cur_y,sel_stx,sel_sty))
00605                       {
00606                         case 1:
00607                                              sel_enx = cur_x;
00608                                              sel_eny = cur_y;
00609                                 break;
00610                         case -1:
00611                                 sel_stx = cur_x;
00612                                       sel_sty = cur_y;
00613                                 break;
00614                         case 0:
00615                                 is_sel = false;
00616                                 break;
00617                       }
00618                           }
00619                                  else
00620                                   {
00621                            is_sel = true;
00622                                    sel_stx = cur_x;
00623                                    sel_sty = cur_y;
00624                                    sel_enx = prev_cur_x;
00625                                    sel_eny = prev_cur_y;
00626                                   }
00627                     break;
00628         case DOWN       :
00629                                  if(cur_y < max_row -1)
00630                                   {
00631                                      cur_y++;
00632                                    if(cur_x > strlen(txt[cur_y]))
00633                                 cur_x = strlen(txt[cur_y]);
00634                                    updateCursor();
00635                           }
00636                 if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00637                   return;
00638                                  if(is_sel)
00639                                   {
00640                      switch(ptcmp(cur_x,cur_y,sel_enx,sel_eny))
00641                       {
00642                         case 1:
00643                                              sel_enx = cur_x;
00644                                              sel_eny = cur_y;
00645                                 break;
00646                         case -1:
00647                                 sel_stx = cur_x;
00648                                       sel_sty = cur_y;
00649                                 break;
00650                         case 0:
00651                                 is_sel = false;
00652                                 break;
00653                       }
00654                      }
00655                                  else
00656                                   {
00657                    is_sel = true;
00658                                    sel_enx = cur_x;
00659                                    sel_eny = cur_y;
00660                                    sel_stx = prev_cur_x;
00661                                    sel_sty = prev_cur_y;
00662                                     }
00663                          break;
00664 
00665         case HOME       :
00666                          cur_x = 0;
00667                    updateCursor();
00668                    if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00669                     return;
00670                                  if(is_sel)
00671                                     {
00672                      switch(ptcmp(cur_x,cur_y,sel_stx,sel_sty))
00673                       {
00674                         case 1:
00675                                              sel_enx = cur_x;
00676                                              sel_eny = cur_y;
00677                                 break;
00678                         case -1:
00679                                 sel_stx = cur_x;
00680                                       sel_sty = cur_y;
00681                                 break;
00682                         case 0:
00683                                 is_sel = false;
00684                                 break;
00685                       }
00686                           }
00687                                  else
00688                                   {
00689                            is_sel = true;
00690                                    sel_stx = cur_x;
00691                                    sel_sty = cur_y;
00692                                    sel_enx = prev_cur_x;
00693                                    sel_eny = prev_cur_y;
00694                                   }
00695                 break;                  
00696         case END        :
00697                                  cur_x = strlen(txt[cur_y]);
00698                                    updateCursor();
00699                  if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00700                    return;
00701                                  if(is_sel)
00702                                   {
00703                      switch(ptcmp(cur_x,cur_y,sel_enx,sel_eny))
00704                       {
00705                         case 1:
00706                                              sel_enx = cur_x;
00707                                              sel_eny = cur_y;
00708                                 break;
00709                         case -1:
00710                                 sel_stx = cur_x;
00711                                       sel_sty = cur_y;
00712                                 break;
00713                         case 0:
00714                                 is_sel = false;
00715                                 break;
00716                       }
00717                      }
00718                                  else
00719                                   {
00720                    is_sel = true;
00721                                    sel_enx = cur_x;
00722                                    sel_eny = cur_y;
00723                                    sel_stx = prev_cur_x;
00724                                    sel_sty = prev_cur_y;
00725                                     }
00726                  break;
00727         case PAGE_UP    :
00728                                  if(st_row - visi_rows >= 0)
00729                                  {
00730                                    st_row -= visi_rows - 1;
00731                                    cur_y  -= visi_rows;
00732                                  }
00733                                  else
00734                                  {
00735                             cur_y = 0;
00736                             st_row = 0;
00737                                  }
00738                                 if(cur_x > strlen(txt[cur_y]))
00739                                          cur_x = strlen(txt[cur_y]);
00740                    if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00741                      return;
00742                                  if(is_sel)
00743                                     {
00744                      switch(ptcmp(cur_x,cur_y,sel_stx,sel_sty))
00745                       {
00746                         case 1:
00747                                              sel_enx = cur_x;
00748                                              sel_eny = cur_y;
00749                                 break;
00750                         case -1:
00751                                 sel_stx = cur_x;
00752                                       sel_sty = cur_y;
00753                                 break;
00754                         case 0:
00755                                 is_sel = false;
00756                                 break;
00757                       }
00758                           }
00759                                  else
00760                                   {
00761                            is_sel = true;
00762                                    sel_stx = cur_x;
00763                                    sel_sty = cur_y;
00764                                    sel_enx = prev_cur_x;
00765                                    sel_eny = prev_cur_y;
00766                                   }
00767 
00768 
00769                           break;
00770         case PAGE_DOWN  :
00771                                 if(st_row + visi_rows < max_row)
00772                                 {
00773                                    st_row += visi_rows - 1;
00774                                    if(cur_y + visi_rows < max_row)
00775                                      cur_y  += visi_rows;
00776                            else
00777                                      cur_y = max_row - 1;
00778                                 }
00779                         else
00780                                  {
00781                                       cur_y = max_row - 1;
00782                                  }
00783                          if(cur_x > strlen(txt[cur_y]))
00784                                 cur_x = strlen(txt[cur_y]);
00785 
00786                  if(cur_y == prev_cur_y && cur_x == prev_cur_x)
00787                   return;
00788                                  if(is_sel)
00789                                   {
00790                      switch(ptcmp(cur_x,cur_y,sel_enx,sel_eny))
00791                       {
00792                         case 1:
00793                                              sel_enx = cur_x;
00794                                              sel_eny = cur_y;
00795                                 break;
00796                         case -1:
00797                                 sel_stx = cur_x;
00798                                       sel_sty = cur_y;
00799                                 break;
00800                         case 0:
00801                                 is_sel = false;
00802                                 break;
00803                       }
00804                      }
00805                                  else
00806                                   {
00807                    is_sel = true;
00808                                    sel_enx = cur_x;
00809                                    sel_eny = cur_y;
00810                                    sel_stx = prev_cur_x;
00811                                    sel_sty = prev_cur_y;
00812                                     }
00813                                  break;
00814        }
00815       }
00816      }
00817 
00818  if(ch < ESC)
00819  {
00820    is_sel = false;
00821    switch(ch)
00822         {
00823          case VK_BACKSPACE :
00824                         if(!(state & ST_SHIFT))
00825                         {
00826                         total_chars = strlen(txt[cur_y]);
00827                         if(cur_x > 0)
00828                          {
00829                          for(i=cur_x-1;i<total_chars - 1;i++)
00830                           txt[cur_y][i] = txt[cur_y][i+1];
00831 
00832                          txt[cur_y][total_chars-1] = '\0';
00833                          cur_x--;
00834                          }
00835                          else
00836                           {
00837                            if(cur_y == 0)
00838                             return;
00839 
00840                            strcat(txt[cur_y -1],txt[cur_y]);
00841 
00842                            for(i=cur_y;i<max_row - 1;i++)
00843                              strcpy(txt[i],txt[i+1]);
00844 
00845                            strcpy(txt[i],"");
00846                            max_row--;
00847                            cur_y--;
00848                            cur_x = strlen(txt[cur_y]);
00849                           }
00850                          }
00851                         break;
00852          case VK_ENTER:
00853                         total_chars = strlen(txt[cur_y]);
00854                         if(max_row >= TEXTAREA_ROWS)
00855                           return;
00856 
00857                         for(i=max_row;i>cur_y +1;i--)
00858                            strcpy(txt[i],txt[i-1]);
00859 
00860                         if(cur_x == total_chars)
00861                          strcpy(txt[cur_y+1],"");
00862                         else
00863                         {
00864                          strmncpy(txt[cur_y+1],txt[cur_y],cur_x,total_chars - cur_x);
00865                          txt[cur_y][cur_x] = '\0';
00866                         }
00867                          cur_y++;
00868                          cur_x = 0;
00869                          max_row++;
00870                         break;
00871 
00872    default :
00873                 total_chars = strlen(txt[cur_y]);
00874                 if(total_chars >= TEXTAREA_COLS)
00875                         return;
00876 
00877                 for(i=total_chars;i>cur_x;i--)
00878                         txt[cur_y][i] = txt[cur_y][i-1];
00879 
00880                 txt[cur_y][total_chars+1] = '\0';
00881 
00882                 txt[cur_y][cur_x] = ch;
00883 
00884                 cur_x++;
00885         }
00886  }
00887 
00888     updateCursor();
00889     restoreImage(mcurx,mcury);
00890     paint();
00891     if(mouse_inited)
00892     {
00893       getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
00894     }
00895     mvMini2Svga(pt.x,pt.y,width,height);
00896    }
00897 
00898   void textarea::setText(char * text)
00899    {
00900     DW i,k;
00901     DW num_chars;
00902     DW rows = 0;
00903     POINT pt;
00904     pt = getAbsLoc(this);
00905     num_chars = strlen(text);
00906     for(i=0;i<num_chars;i++)
00907       {
00908         if(text[i] == '\n')
00909          {
00910            txt[rows][k] = '\0';
00911            k = 0;
00912            rows++;
00913          }
00914         else
00915          {
00916            txt[rows][k] = text[i];
00917                  k++;
00918          }
00919       }
00920       if(k != 0)
00921         txt[rows][k] = '\0';
00922      st_row = 0;
00923      st_col = 0;
00924      max_row = rows + 1;
00925 
00926  /* if(this == focus->focus_ptr)
00927     {
00928      cur_x = 0;
00929      cur_y = 0;
00930      updateCursor();
00931     } */
00932 
00933     restoreImage(mcurx,mcury);
00934     paint();
00935     if(mouse_inited)
00936     {
00937       getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
00938     }
00939     mvMini2Svga(pt.x,pt.y,width,height);
00940    }
00941 
00942   void textarea::getText(char * text)
00943    {
00944     DW i;
00945 
00946     strcpy(text,"");
00947     for(i=0;i<max_row-1;i++)
00948      {
00949       strcat(text,txt[i]);
00950       strcat(text,"\n");
00951      }
00952      strcat(text,txt[i]);
00953    }
00954    
00955    void textarea::copy()
00956    {
00957     SDW i,j,k;
00958 
00959     if(!is_sel)
00960      return;
00961     k = 0;
00962     
00963     if(sel_sty == sel_eny)
00964      {
00965        for(j = sel_stx; j < sel_enx ;j++)
00966         {
00967           clip[k] = txt[sel_sty][j];
00968           k++;
00969         }
00970        clip[k] = '\0';
00971      }
00972     else
00973     { 
00974      for(j = sel_stx; j <strlen(txt[sel_sty]);j++)
00975         {
00976           clip[k] = txt[sel_sty][j];
00977           k++;
00978         }
00979     clip[k] = '\n';
00980     k++;    
00981     for(i = sel_sty + 1; i < sel_eny;i++)
00982      {                         
00983        for(j = 0; j <strlen(txt[i]);j++)
00984         {
00985           clip[k] = txt[i][j];
00986           k++;
00987         }
00988        clip[k] = '\n';
00989        k++;     
00990      }
00991       for(j = 0; j < sel_enx;j++)
00992         {
00993           clip[k] = txt[sel_eny][j];
00994           k++;
00995         }
00996      clip[k] = '\0';
00997    } 
00998     cl_pres = true;    
00999    }
01000  void textarea::cut()
01001   {     
01002    SDW i,j,k,len;
01003    DW num_lines;
01004    DW total_chars;
01005    POINT pt;
01006    pt =getAbsLoc(this);
01007 
01008    if(!is_sel)
01009     return;
01010 
01011     k = 0;
01012     num_lines = sel_eny - sel_sty;
01013     if(num_lines == 0)
01014      {
01015        len =  sel_enx - sel_stx;
01016        for(j = sel_stx; j < sel_enx ;j++)
01017         {
01018           clip[k] = txt[sel_sty][j];
01019           k++;
01020         }        
01021        clip[k] = '\0';
01022 
01023        total_chars = strlen(txt[sel_sty]);
01024        
01025        for(i = sel_stx;i<total_chars;i++)
01026          txt[sel_sty][i] = txt[sel_sty][i + len];
01027 
01028        total_chars -= len;
01029        txt[sel_sty][total_chars] = '\0';
01030      }
01031     else
01032     {
01033      for(j = sel_stx; j <strlen(txt[sel_sty]);j++)
01034         {
01035           clip[k] = txt[sel_sty][j];
01036           k++;
01037         }
01038     clip[k] = '\n';
01039     k++;
01040     for(i = sel_sty + 1; i < sel_eny;i++)
01041      {
01042        for(j = 0; j <strlen(txt[i]);j++)
01043         {
01044           clip[k] = txt[i][j];
01045           k++;
01046         }
01047        clip[k] = '\n';
01048        k++;
01049      }
01050       for(j = 0; j < sel_enx;j++)
01051         {
01052           clip[k] = txt[sel_eny][j];
01053           k++;
01054         }
01055      clip[k] = '\0';
01056 
01057      for(i = sel_enx; i < strlen(txt[sel_eny]) ; i++)
01058        txt[sel_sty][sel_stx + i - sel_enx] =txt[sel_eny][i];
01059 
01060      txt[sel_sty][sel_stx + i - sel_enx] = '\0';
01061 
01062      for(i = sel_sty + 1; i < max_row ;i++)
01063       strcpy(txt[i],txt[i+num_lines]);
01064 
01065      max_row -= num_lines;  
01066    }
01067     cl_pres = true;
01068     
01069     cur_x = sel_stx;
01070     cur_y = sel_sty;
01071 
01072   cl_pres = true;
01073   is_sel = false;
01074   updateCursor();
01075   restoreImage(mcurx,mcury);
01076         paint();
01077         if(mouse_inited)
01078                 {
01079                 getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
01080                 }
01081         mvMini2Svga(pt.x,pt.y,width,height);
01082 }
01083    void textarea::paste()
01084    {
01085      SDW i,j,k;
01086      DW cl_enx = 0;
01087      DW num_lines = 0;
01088      DW len;
01089      DW total_chars;
01090      POINT pt;
01091      pt =getAbsLoc(this);
01092 
01093      if(!cl_pres)
01094       return;
01095 
01096       len = strlen(clip);
01097       for(i = 0;i<len;i++)
01098          {
01099               if(clip[i] == '\n')
01100          {
01101           num_lines++;
01102           cl_enx = i + 1;
01103          }
01104          }
01105       if(num_lines == 0)
01106        {
01107          total_chars = strlen(txt[cur_y]);
01108          for(i = total_chars - 1; i >= cur_x ; i--)
01109           txt[cur_y][i + len] = txt[cur_y][i];
01110          for(j = 0;j <len;j++)
01111           {
01112            txt[cur_y][j+cur_x] = clip[j];
01113           }
01114         total_chars += len;
01115         txt[cur_y][total_chars] = '\0';
01116         cur_x = cur_x + len;
01117        }
01118       else
01119        {
01120           for(i = max_row -1; i > cur_y; i--)
01121             strcpy(txt[i + num_lines],txt[i]);
01122 
01123           total_chars = strlen(txt[cur_y]);
01124           strmncpy(txt[cur_y + num_lines],clip,cl_enx,len - cl_enx);
01125 
01126           for(i = cur_x; i < total_chars; i++)
01127             txt[cur_y + num_lines][len-cl_enx + i - cur_x] = txt[cur_y][i];
01128 
01129           txt[cur_y + num_lines][len-cl_enx + i - cur_x] = '\0';
01130 
01131 
01132           for(i = total_chars - 1; i >= cur_x ; i--)
01133               txt[cur_y][i + len] = txt[cur_y][i];
01134 
01135           for(i = 0; i < len ; i++)
01136            {
01137             if(clip[i] != '\n')
01138              txt[cur_y][cur_x + i] = clip[i];
01139             else
01140               break;
01141            }
01142            txt[cur_y][cur_x + i] = '\0';
01143 
01144           if(num_lines != 1)
01145           {
01146            j = cur_y + 1;
01147            k = 0;
01148            i++;
01149           for(; i < len; i++)
01150            {
01151              if(clip[i] == '\n')
01152               {
01153                txt[j][k] = '\0';
01154                j++;
01155                k = 0;
01156               }
01157              else
01158               {
01159                txt[j][k] = clip[i];
01160                k++;
01161               }
01162            }
01163           }
01164           max_row += num_lines;
01165           cur_y = cur_y + num_lines;
01166           cur_x = strlen(txt[cur_y]);
01167         }
01168        updateCursor();
01169        restoreImage(mcurx,mcury);
01170          paint();
01171          if(mouse_inited)
01172                 {
01173                     getimage(mcurx,mcury,16,16, &mouseimg[0][0]);
01174                 }
01175          mvMini2Svga(pt.x,pt.y,width,height);
01176    }
01177 
01178   SDW textarea::ptcmp(DW x1,DW y1,DW x2,DW y2)
01179    {
01180            if(y1 > y2)
01181             {
01182          return 1;           
01183         }
01184         else if(y1 == y2)
01185                     {
01186                             if(x1 > x2)
01187                             {
01188              return 1;
01189                             }
01190                 else if(x1 == x2)
01191             return 0;
01192             else
01193                              {
01194               return -1;
01195                              }
01196               }
01197                    else
01198                             {
01199            return -1;
01200                             }
01201    }  

Generated on Thu Jul 27 23:52:27 2006 for Dynacube by  doxygen 1.4.7