API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 19th, 2019
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 40.68 KB | None | 0 0
raw download clone embed print report
  1. #include<bits/stdc++.h>
  2. #include<SDL2/SDL.h>
  3. #include<SDL2/SDL_image.h>
  4. #include<SDL2/SDL_ttf.h>
  5.  
  6.  
  7. const int SCREEN_WIDTH = 400;
  8. const int SCREEN_HEIGHT = 400;
  9. int Font_WIDTH = 40;
  10. int day=1, month, year=10;
  11. char date[50];
  12.  
  13.  
  14.  
  15.  
  16.  
  17. class LTexture
  18. {
  19.  
  20. public:
  21.  
  22.     LTexture();
  23.     ~LTexture();
  24.     bool loadFromFile(std::string path);
  25.  
  26. #if defined(_SDL_TTF_H) || defined(SDL_TTF_H)
  27.     bool loadFromRenderedText( std::string textureText, SDL_Color textColor );
  28. #endif
  29.  
  30.     void free();
  31.     void setColor(Uint8 red, Uint8 green, Uint8 blue);
  32.     void setBlendMode(SDL_BlendMode blending);
  33.     void setAlpha(Uint8 alpha);
  34.     void render(int x, int y, SDL_Rect* clip = NULL, double angle = 0.0, SDL_Point* center = NULL, SDL_RendererFlip flip = SDL_FLIP_NONE );
  35.     int getWidth();
  36.     int getHeight();
  37.  
  38. private:
  39.     SDL_Texture* mTexture;
  40.     int mWidth;
  41.     int mHeight;
  42.  
  43. };
  44.  
  45.  
  46. LTexture gDotTexture;
  47.  
  48. class Dot
  49. {
  50. public:
  51.     //The dimensions of the dot
  52.     static const int DOT_WIDTH = 20;
  53.     static const int DOT_HEIGHT = 20;
  54.  
  55.     //Maximum axis velocity of the dot
  56.     static const int DOT_VEL = 10;
  57.  
  58.     //Initializes the variables
  59.     Dot();
  60.  
  61.     //Takes key presses and adjusts the dot's velocity
  62.     void handleEvent( SDL_Event& e );
  63.  
  64.     //Moves the dot
  65.     void move();
  66.  
  67.     //Shows the dot on the screen
  68.     void render();
  69.  
  70. private:
  71.     //The X and Y offsets of the dot
  72.     int mPosX, mPosY;
  73.  
  74.     //The velocity of the dot
  75.     int mVelX, mVelY;
  76. };
  77.  
  78. Dot::Dot()
  79. {
  80.     //Initialize the offsets
  81.     mPosX = 0;
  82.     mPosY = 0;
  83.  
  84.     //Initialize the velocity
  85.     mVelX = 0;
  86.     mVelY = 0;
  87. }
  88.  
  89.  
  90.  
  91. bool init();
  92. bool loadMedia();
  93. void close();
  94.  
  95. SDL_Window* main_window = NULL;
  96. SDL_Renderer* main_renderer = NULL;
  97. TTF_Font* main_font=NULL;
  98. LTexture mainTextTexture[50];
  99. LTexture Ltemp;
  100. LTexture indi;
  101. LTexture header;
  102. LTexture Ttemp;
  103.  
  104. LTexture::LTexture()
  105. {
  106.     mTexture = NULL;
  107.     mWidth = 0;
  108.     mHeight = 0;
  109. }
  110.  
  111. LTexture::~LTexture()
  112. {
  113.     free();
  114. }
  115.  
  116. bool LTexture::loadFromFile(std:: string path)
  117. {
  118.     free();
  119.     SDL_Texture* newTexture = NULL;
  120.     SDL_Surface* loadedSurface = IMG_Load(path.c_str());
  121.     if(loadedSurface==NULL)
  122.     {
  123.         printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
  124.     }
  125.     else
  126.     {
  127.         SDL_SetColorKey(loadedSurface, SDL_TRUE, SDL_MapRGB(loadedSurface->format, 0, 0xFF, 0xFF));
  128.         newTexture = SDL_CreateTextureFromSurface(main_renderer, loadedSurface);
  129.         if( newTexture == NULL )  printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
  130.  
  131.         else
  132.         {
  133.             mWidth = loadedSurface->w;
  134.             mHeight = loadedSurface->h;
  135.         }
  136.         SDL_FreeSurface(loadedSurface);
  137.     }
  138.     mTexture = newTexture;
  139.     return mTexture !=NULL;
  140. }
  141.  
  142.  
  143. #if defined(_SDL_TTF_H) || defined(SDL_TTF_H)
  144. bool LTexture::loadFromRenderedText(std::string textureText, SDL_Color textColor)
  145. {
  146.  
  147.     free();
  148.  
  149.     SDL_Surface* textSurface = TTF_RenderText_Solid(main_font, textureText.c_str(), textColor);
  150.     if( textSurface == NULL ) printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
  151.     else
  152.     {
  153.         mTexture = SDL_CreateTextureFromSurface(main_renderer, textSurface);
  154.         if(mTexture == NULL)    printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
  155.         else
  156.         {
  157.             mWidth = textSurface->w;
  158.             mHeight = textSurface->h;
  159.         }
  160.         SDL_FreeSurface(textSurface);
  161.     }
  162.     return mTexture!=NULL;
  163. }
  164.  
  165. #endif
  166.  
  167. void LTexture::free()
  168. {
  169.     if(mTexture!=NULL)
  170.     {
  171.         SDL_DestroyTexture(mTexture);
  172.         mTexture = NULL;
  173.         mWidth = 0;
  174.         mHeight = 0;
  175.     }
  176. }
  177.  
  178.  
  179.  
  180.  
  181. void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue)
  182. {
  183.     SDL_SetTextureColorMod(mTexture, red, green, blue);
  184.  
  185. }
  186.  
  187. void LTexture::setBlendMode(SDL_BlendMode blending)
  188. {
  189.     SDL_SetTextureBlendMode(mTexture, blending);
  190. }
  191.  
  192. void LTexture::setAlpha(Uint8 alpha)
  193. {
  194.     SDL_SetTextureAlphaMod(mTexture, alpha);
  195. }
  196.  
  197. void LTexture::render(int x, int y, SDL_Rect* clip, double angle, SDL_Point* center, SDL_RendererFlip flip)
  198. {
  199.     SDL_Rect renderQuad = {x,y,mWidth,mHeight};
  200.     if(clip!=NULL)
  201.     {
  202.         renderQuad.w = clip->w;
  203.         renderQuad.h = clip->h;
  204.     }
  205.     SDL_RenderCopyEx(main_renderer, mTexture, clip, &renderQuad, angle, center, flip);
  206. }
  207.  
  208.  
  209. int LTexture::getWidth()
  210. {
  211.     return mWidth;
  212. }
  213.  
  214. int LTexture::getHeight()
  215. {
  216.     return mHeight;
  217. }
  218.  
  219. bool init()
  220. {
  221.     bool success = true;
  222.     if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  223.     {
  224.         printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
  225.         success = false;
  226.     }
  227.     else
  228.     {
  229.         if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY,"1")) printf("Warning: Linear texture filtering not enabled!" );
  230.         main_window = SDL_CreateWindow("100% NIGGA",0,0,SCREEN_WIDTH,SCREEN_HEIGHT,SDL_WINDOW_SHOWN);
  231.         if(main_window==NULL)
  232.         {
  233.             printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
  234.             success = false;
  235.         }
  236.         else
  237.         {
  238.             main_renderer = SDL_CreateRenderer(main_window,-1,SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  239.             if( main_renderer == NULL )
  240.             {
  241.                 printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
  242.                 success = false;
  243.             }
  244.             else
  245.             {
  246.                 SDL_SetRenderDrawColor(main_renderer, 0xFF,0xFF,0xFF,0xFF);
  247.                 int imgFlags = IMG_INIT_PNG;
  248.                 if(!(IMG_Init(imgFlags)&imgFlags))
  249.                 {
  250.                     printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
  251.                     success = false;
  252.                 }
  253.                 if( TTF_Init() == -1 )
  254.                 {
  255.                     printf( "SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError() );
  256.                     success = false;
  257.                 }
  258.             }
  259.         }
  260.     }
  261.     return success;
  262. }
  263.  
  264. bool loadMedia()
  265. {
  266.     bool success = true;
  267.  
  268.     main_font = TTF_OpenFont("boy.ttf", Font_WIDTH);
  269.     if(main_font==NULL)
  270.     {
  271.         printf( "Failed to load font! SDL_ttf Error: %s\n", TTF_GetError() );
  272.         success = false;
  273.     }
  274.     else
  275.     {
  276.         SDL_Color hColor = {0xD3,0xFF,0xCE};
  277.         if(!header.loadFromRenderedText(date,hColor))
  278.         {
  279.             printf( "Failed to render text texture!\n" );
  280.             success = false;
  281.         }
  282.     }
  283.     //Load dot texture
  284.     if( !gDotTexture.loadFromFile( "white_nigga.png" ) )
  285.     {
  286.         printf( "Failed to load dot texture!\n" );
  287.         success = false;
  288.     }
  289.  
  290.     return success;
  291. }
  292.  
  293. void close()
  294. {
  295.     for(int i=0; i<50; i++)
  296.     {
  297.         mainTextTexture[i].free();
  298.     }
  299.     gDotTexture.free();
  300.     header.free();
  301.     TTF_CloseFont(main_font);
  302.     main_font = NULL;
  303.     SDL_DestroyRenderer(main_renderer);
  304.     main_renderer = NULL;
  305.     SDL_DestroyWindow(main_window);
  306.  
  307.     main_window = NULL;
  308.     TTF_Quit();
  309.     IMG_Quit();
  310.     SDL_Quit();
  311. }
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337. int main(int argn, char* args[])
  338. {
  339.  
  340.     int z=0,p=0,q,count=0,x=0,current_line=0,c=0,total_line=0,flag=0,backspace_check=0,length,side_count=0;
  341.     int left_sign=0,tchar[100]={0},indi_xpos,indi_xpos_width[1000],final_indi_xpos,huda,left_check,middle_backspace=0;
  342.     int right_new_line=0,left_new_line=0,previous_line_indi_xpos=0,r_length,l_length,ctrl_count=0,all_select=0;
  343.     int scroll_count=0,max_line=0,up_sign=0,total_length=0;
  344.     char s[1001000],v[100][2002],ctemp[1000],char_temp,stemp[1000];
  345.  
  346.  
  347.     // printf("ENTER DATE. In format 11 10 2019!\n");
  348.     // scanf("%d %d %d", &day, &month, &year);
  349.     // if(month==1) sprintf(date, "%d th January, %d", day, year);
  350.     // else if(month==2) sprintf(date, "%d th February, %d", day, year);
  351.     // else if(month==3) sprintf(date, "%d th March, %d", day, year);
  352.     // else if(month==4) sprintf(date, "%d th April, %d", day, year);
  353.     // else if(month==5) sprintf(date, "%d th May, %d", day, year);
  354.     // else if(month==6) sprintf(date, "%d th June, %d", day, year);
  355.     // else if(month==7) sprintf(date, "%d th July, %d", day, year);
  356.     // else if(month==8) sprintf(date, "%d th August, %d", day, year);
  357.     // else if(month==9) sprintf(date, "%d th September, %d", day, year);
  358.     // else if(month==10) sprintf(date, "%d th October, %d", day, year);
  359.     // else if(month==11) sprintf(date, "%d th Novermber, %d", day, year);
  360.     sprintf(date, "%d th December, %d", day, year);
  361.  
  362.  
  363.     if(!init()) printf("Failed to initialize/n");
  364.     else
  365.     {
  366.         if(!loadMedia()) printf("Failed to load media\n");
  367.         else
  368.         {
  369.  
  370.             bool quit = false;
  371.             SDL_Event e;
  372.             SDL_Color textColor = {0xFF,0xFF,0xFF};
  373.             std::string inputText[50];
  374.             std::string fulltext;
  375.             std::string copyText[50];
  376.             std::string sh;
  377.             std::string itTemp;
  378.             //for(int k=0; k<50; k++) inputText[k] = "";
  379.             Dot dot;
  380.             SDL_StartTextInput();
  381.             while(!quit)
  382.             {
  383.                 bool renderText = false;
  384.  
  385.                 while(SDL_PollEvent(&e)!=0)
  386.                 {
  387.  
  388.                    
  389.  
  390.                     if(e.type == SDL_QUIT) quit = true;
  391.  
  392.  
  393.                     else if(e.type == SDL_KEYDOWN)
  394.                     {
  395.  
  396.                        
  397.  
  398.                         huda=1;
  399.  
  400.  
  401.                         //backspace key
  402.  
  403.  
  404.  
  405.  
  406.  
  407.                         if( e.key.keysym.sym == SDLK_BACKSPACE )
  408.                         {
  409.  
  410.                             if(all_select==1)
  411.                              {
  412.                                 all_select=0;
  413.                                 sh=" ";
  414.                                 for(int i=0;i<=total_line;i++)
  415.                                 {
  416.                                     inputText[i]=sh;
  417.                                     mainTextTexture[i].loadFromRenderedText(inputText[i],textColor);
  418.                                     inputText[i].pop_back();
  419.                                 }
  420.                                 total_line=0;
  421.                                 current_line=0;
  422.                                 indi_xpos=0;
  423.                                
  424.                                
  425.                              }
  426.                              //first line er majh theke kichu katle last e atkai zabe
  427.                              else if(current_line==0&&indi_xpos==0&&left_sign>0);
  428.  
  429.                              //normal lst line katar jonno
  430.                              else if(final_indi_xpos==0&&current_line!=0&&total_line==current_line&&left_sign<1)
  431.                              {
  432.                              
  433.                                 backspace_check=1;
  434.                                 current_line--;
  435.                                 left_sign=0;
  436.                                 total_line--;
  437.                              }
  438.  
  439.  
  440.  
  441.                              //full line er majh theke katle
  442.                              // else if(final_indi_xpos==0&&left_sign>0||final_indi_xpos==0&&current_line<total_line)
  443.                              // {
  444.                              //     fulltext="";
  445.                              //     for(int i=0;i<100;i++)
  446.                              //     {
  447.  
  448.  
  449.  
  450.                              //         fulltext=fulltext+inputText[i];
  451.                              //         if(i==current_line-1)total_length=strlen(fulltext.c_str());
  452.                              //         if(mainTextTexture[i].getWidth()<SCREEN_WIDTH-100)
  453.                              //         {
  454.                                        
  455.                              //             break;
  456.                              //         }
  457.  
  458.                              //     }
  459.  
  460.  
  461.  
  462.  
  463.  
  464.                              // }
  465.  
  466.                              
  467.  
  468.  
  469.                             else if(left_sign<1)
  470.                             {
  471.  
  472.                              
  473.  
  474.  
  475.  
  476.  
  477.                                 //backspace main part
  478.  
  479.  
  480.  
  481.                                 if(inputText[current_line].length()==0&&current_line!=0)
  482.                                 {
  483.                                    
  484.  
  485.                                     //if(mainTextTexture[current_line-1].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  486.                                     //majher ekta line kaatle
  487.  
  488.                              
  489.                                    if(current_line<total_line)
  490.                                     {
  491.                                           for(int a=0;a<total_line-current_line;a++)
  492.                                           {
  493.                                             sh=inputText[current_line+a];
  494.                                             inputText[current_line+a]=inputText[current_line+1+a];
  495.                                             inputText[current_line+1+a]=sh;
  496.                                             mainTextTexture[current_line+a].loadFromRenderedText( inputText[current_line+a].c_str(), textColor );
  497.                                           }
  498.                                         }
  499.  
  500.                                         if(total_line>0)total_line--;
  501.                                         current_line--;
  502.                                      
  503.                                         left_sign=0;
  504.                                        
  505.                                        
  506.  
  507.  
  508.                                         if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100&&total_line>=0)
  509.                                         {
  510.                                             backspace_check=1;
  511.                                        
  512.                                         }
  513.                                         renderText = false;
  514.                                         mainTextTexture[current_line].loadFromRenderedText( inputText[current_line].c_str(), textColor );
  515.                                     }
  516.  
  517.                                 //first line zodi delete dite thaki
  518.  
  519.                                 else if(inputText[current_line].length()==0&&current_line==0)
  520.                                 {
  521.                                    
  522.  
  523.                                      if(current_line<total_line)
  524.                                     {
  525.                                       for(int a=0;a<total_line;a++)
  526.                                       {
  527.                                         sh=inputText[1+a];
  528.                                         inputText[a]=inputText[1+a];
  529.                                         inputText[1+a]=sh;
  530.                                         mainTextTexture[a].loadFromRenderedText( inputText[current_line+a].c_str(), textColor );
  531.                                       }
  532.                                     }
  533.  
  534.                                     if(total_line>0)total_line--;
  535.                                     current_line=0;
  536.                                    
  537.                                    
  538.                                     left_sign=strlen(inputText[current_line].c_str());
  539.                                 }
  540.  
  541.                                 //indicator er karone width bere gele overflow line theke kaTAr jonno
  542.  
  543.  
  544.                                 else if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100)
  545.                                 {
  546.                                     //printf("%d %d\n",current_line,mainTextTexture[current_line-1].getWidth() );
  547.                                     inputText[current_line].pop_back();
  548.                                     mainTextTexture[current_line].loadFromRenderedText( inputText[current_line].c_str(), textColor );
  549.                                     renderText = false;
  550.  
  551.                                 }
  552.  
  553.  
  554.  
  555.  
  556.  
  557.  
  558.  
  559.                                 else if(inputText[current_line].length() > 0)
  560.                                 {
  561.                                     inputText[current_line].pop_back();
  562.                                     renderText = true;
  563.                                 }
  564.                             }
  565.  
  566.                             else
  567.                                 {
  568.  
  569.                                     if(final_indi_xpos==0)
  570.                                     {
  571.                                         current_line--;
  572.                                         left_sign=0;
  573.                                         if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  574.  
  575.  
  576.                                     }
  577.                                     else
  578.                                     {
  579.  
  580.                                     if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  581.                                     middle_backspace=1;
  582.                                     renderText=true;
  583.                                     }
  584.                                 }
  585.                                 // printf("%d\n",left_sign );
  586.                         }
  587.  
  588.                         if(e.key.keysym.sym !=SDL_GetModState() & KMOD_CTRL)all_select=0;
  589.  
  590.  
  591.  
  592.                         //Up key
  593.  
  594.  
  595.  
  596.                         if( e.key.keysym.sym == SDLK_UP )
  597.                         {
  598.                            
  599.                          
  600.  
  601.                             if(current_line>0)
  602.                            
  603.                             {
  604.                                 //indicator y axis e align kora
  605.  
  606.  
  607.                              
  608.                                 {
  609.                                    
  610.  
  611.                                     previous_line_indi_xpos=final_indi_xpos;
  612.  
  613.                                     if(mainTextTexture[current_line-1].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  614.  
  615.                                     current_line--;
  616.                                    
  617.  
  618.                                     if(mainTextTexture[current_line].getWidth()<=previous_line_indi_xpos)left_sign=0;
  619.  
  620.  
  621.                                     else
  622.                                     {
  623.                                        
  624.  
  625.                                         for(int i=0;i<strlen(inputText[current_line].c_str())-1;i++)
  626.                                         {
  627.  
  628.                                             ctemp[i]=inputText[current_line].c_str()[i];
  629.                                             ctemp[i+1]=0;
  630.                                             Ltemp.loadFromRenderedText( ctemp, textColor );
  631.                                             l_length=Ltemp.getWidth();
  632.  
  633.  
  634.  
  635.                                             ctemp[i+1]=inputText[current_line].c_str()[i+1];
  636.                                             ctemp[i+1+1]=0;
  637.                                             Ltemp.loadFromRenderedText( ctemp, textColor );
  638.                                             r_length=Ltemp.getWidth();
  639.  
  640.                                                
  641.  
  642.                                             if(previous_line_indi_xpos>=l_length&&previous_line_indi_xpos<=r_length)
  643.                                             {
  644.                                                 if(previous_line_indi_xpos-l_length<=r_length-previous_line_indi_xpos)
  645.                                                 {
  646.                                                     left_sign=strlen(inputText[current_line].c_str())-i-1;
  647.                                                     break;
  648.                                                 }
  649.                                                 else
  650.                                                 {
  651.                                                     left_sign=strlen(inputText[current_line].c_str())-i-2;
  652.                                                     break;
  653.                                                 }
  654.  
  655.  
  656.                                             }
  657.  
  658.  
  659.                                         }
  660.                                     }
  661.  
  662.  
  663.                                 }
  664.                              
  665.  
  666.  
  667.                          
  668.                              
  669.  
  670.                             }
  671.                             else
  672.                             {
  673.                                 backspace_check=1;
  674.                                 current_line=0;
  675.                              
  676.                             }
  677.                             renderText=false;
  678.                         }
  679.  
  680.  
  681.  
  682.  
  683.  
  684.  
  685.                         //down key
  686.  
  687.  
  688.  
  689.                         else if( e.key.keysym.sym == SDLK_DOWN &&inputText[current_line].length()>0)
  690.                         {
  691.                            
  692.                             if(current_line<total_line)
  693.                             {
  694.  
  695.                                 {
  696.                                    
  697.  
  698.                                     previous_line_indi_xpos=final_indi_xpos;
  699.  
  700.                                     if(mainTextTexture[current_line+1].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  701.  
  702.                                     current_line++;
  703.                                
  704.  
  705.                                     if(mainTextTexture[current_line].getWidth()<=previous_line_indi_xpos)left_sign=0;
  706.  
  707.  
  708.                                     else
  709.                                     {
  710.                                        
  711.  
  712.                                         for(int i=0;i<strlen(inputText[current_line].c_str())-1;i++)
  713.                                         {
  714.  
  715.                                             ctemp[i]=inputText[current_line].c_str()[i];
  716.                                             ctemp[i+1]=0;
  717.                                             Ltemp.loadFromRenderedText( ctemp, textColor );
  718.                                             l_length=Ltemp.getWidth();
  719.  
  720.  
  721.  
  722.                                             ctemp[i+1]=inputText[current_line].c_str()[i+1];
  723.                                             ctemp[i+1+1]=0;
  724.                                             Ltemp.loadFromRenderedText( ctemp, textColor );
  725.                                             r_length=Ltemp.getWidth();
  726.  
  727.  
  728.  
  729.                                             if(previous_line_indi_xpos>=l_length&&previous_line_indi_xpos<=r_length)
  730.                                             {
  731.                                                
  732.                                                 if(previous_line_indi_xpos-l_length<=r_length-previous_line_indi_xpos)
  733.                                                 {
  734.                                                     left_sign=strlen(inputText[current_line].c_str())-i-1;
  735.                                                     break;
  736.                                                 }
  737.                                                 else
  738.                                                 {
  739.                                                     left_sign=strlen(inputText[current_line].c_str())-i-2;
  740.                                                     break;
  741.                                                 }
  742.  
  743.                                             }
  744.  
  745.  
  746.                                         }
  747.                                     }
  748.  
  749.  
  750.                                 }
  751.  
  752.  
  753.                                
  754.                    
  755.                                
  756.                             }
  757.  
  758.  
  759.  
  760.                             renderText = false;
  761.                         }
  762.                            
  763.  
  764.  
  765.  
  766.  
  767.                                 //right key
  768.  
  769.                         else if( e.key.keysym.sym == SDLK_RIGHT )
  770.                         {
  771.                            
  772.                           if(left_sign>0)left_sign--;
  773.                              if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100)
  774.                             {
  775.                                 backspace_check=1;
  776.                                
  777.                             }
  778.  
  779.                             //continuous right click
  780.                             if(left_sign<=0&&current_line<total_line)
  781.  
  782.                             {
  783.                                 if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100||right_new_line==1)
  784.                                 {
  785.                                     current_line++;
  786.                                     length=strlen(inputText[current_line].c_str());
  787.                                     left_sign=length;
  788.                                     right_new_line=0;
  789.                                 }
  790.                                 else
  791.  
  792.                                     right_new_line=1;
  793.  
  794.                             }
  795.                         }
  796.  
  797.  
  798.  
  799.  
  800.  
  801.                             //left key
  802.                           else if( e.key.keysym.sym == SDLK_LEFT )
  803.                         {
  804.  
  805.                             //left overflow check
  806.                             if(mainTextTexture[current_line].getWidth()>=SCREEN_WIDTH-100)
  807.                             {
  808.                                 backspace_check=1;
  809.                                 left_check=1;
  810.                             }
  811.                            
  812.                             if(indi_xpos>0)
  813.                             {
  814.                                left_sign++;
  815.                                
  816.                             }
  817.                             if(left_sign==length&&current_line!=0&&left_new_line!=0)
  818.                             {
  819.                                 backspace_check=1;
  820.                                 current_line--;
  821.                                 left_sign=0;
  822.                                 length=strlen(inputText[current_line].c_str());
  823.                                 left_new_line=0;
  824.                             }
  825.  
  826.                             if(left_sign==length&&current_line!=0&&left_new_line==0)
  827.                             {
  828.                                 left_new_line=1;
  829.                             }
  830.  
  831.                         }
  832.  
  833.  
  834.  
  835.  
  836.                         //enter key
  837.  
  838.  
  839.  
  840.                         else if( e.key.keysym.sym == SDLK_RETURN)
  841.                         {
  842.                             //line er majhe enter dile
  843.  
  844.                             if(left_sign>0)
  845.                             {
  846.                                 if(left_sign==length)
  847.                                 {
  848.                                     total_line++;
  849.                                     mainTextTexture[current_line].loadFromRenderedText( "@", textColor );
  850.                                     sh=inputText[current_line];
  851.                                     for(int i=current_line+1;i<=total_line;i++)
  852.                                     {
  853.                                         if(i!=total_line)itTemp=inputText[i];
  854.                                         inputText[i]=sh;
  855.                                         if(i!=total_line) sh=itTemp;
  856.                                         mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  857.                                     }
  858.                                     current_line++;
  859.  
  860.                                 }
  861.                                 else
  862.                                 {
  863.                                     for(int i=0;i<indi_xpos;i++)
  864.                                         ctemp[i]=inputText[current_line].c_str()[i];
  865.                                     ctemp[indi_xpos]=0;
  866.  
  867.  
  868.                                     for(int i=indi_xpos;i<length;i++)
  869.                                         stemp[i-indi_xpos]=inputText[current_line].c_str()[i];
  870.                                     stemp[length-indi_xpos]=0;
  871.  
  872.  
  873.                                     total_line++;
  874.                                     for(int i=0;i<length;i++)
  875.                                         inputText[current_line].pop_back();
  876.  
  877.  
  878.                                     inputText[current_line]=ctemp;
  879.                                     mainTextTexture[current_line].loadFromRenderedText( inputText[current_line].c_str(), textColor );
  880.  
  881.  
  882.                                     sh=inputText[current_line+1];
  883.  
  884.  
  885.                                     inputText[current_line+1]=stemp;
  886.                                     mainTextTexture[current_line+1].loadFromRenderedText( inputText[current_line+1].c_str(), textColor );
  887.  
  888.  
  889.                                     for(int i=current_line+2;i<=total_line;i++)
  890.                                     {
  891.  
  892.                                        if(i!=total_line)itTemp=inputText[i];
  893.                                         inputText[i]=sh;
  894.                                        if(i!=total_line) sh=itTemp;
  895.                                         mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  896.                                        
  897.                                     }
  898.                                     current_line++;
  899.                                 }
  900.  
  901.  
  902.  
  903.                             }
  904.                             else
  905.                             {
  906.  
  907.                                 current_line++;
  908.                                 total_line++;
  909.                                 left_sign=0;
  910.                             }
  911.  
  912.                  
  913.                            //jani na jhamela badhle dekhbo c++;
  914.                             if(inputText[current_line-1].length()==0)flag=1;
  915.                             //mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  916.  
  917.  
  918.                             renderText = false;
  919.                         }
  920.  
  921.  
  922.  
  923.                         //shob select kora
  924.  
  925.                         else if(e.key.keysym.sym == SDLK_a && SDL_GetModState() & KMOD_CTRL)
  926.                         {
  927.                             if(all_select==1)all_select =0;
  928.                             else
  929.                                 all_select=1;
  930.                         }
  931.  
  932.  
  933.  
  934.  
  935.  
  936.  
  937.  
  938.                         //copy something
  939.  
  940.                         else if( e.key.keysym.sym == SDLK_c && SDL_GetModState() & KMOD_CTRL )
  941.                         {
  942.                             for(int i=0; i<=current_line; i++)
  943.                             {
  944.                                 strcat(s,inputText[i].c_str());
  945.                                 if(i!=current_line)strcat(s,"\n");
  946.  
  947.  
  948.  
  949.                             }
  950.                             SDL_SetClipboardText(s);
  951.                             s[0]=0;
  952.                         }
  953.  
  954.                         //paste something
  955.  
  956.  
  957.                         else if( e.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL )
  958.                         {
  959.  
  960.  
  961.  
  962.                             inputText[current_line] = inputText[current_line]+SDL_GetClipboardText();
  963.  
  964.                              int l=strlen(inputText[current_line].c_str());
  965.  
  966.                                 for(int i=0;i<l;i++)stemp[i]=inputText[current_line].c_str()[i];
  967.                                     sh=inputText[current_line];
  968.                                 for(int i=0;i<l;i++)inputText[current_line].pop_back();
  969.  
  970.                                 Ltemp.loadFromRenderedText( sh, textColor );
  971.  
  972.  
  973.                                 if(Ltemp.getWidth()>=SCREEN_WIDTH-100)
  974.                                  {
  975.                                     for(int i=0;i<l;i++)
  976.                                     {
  977.  
  978.  
  979.                                         if(stemp[i]=='\n')continue;
  980.                                             ctemp[count]=stemp[i];
  981.                                             count++;
  982.                                             ctemp[count]=0;
  983.                                        
  984.                                         sh=ctemp;
  985.                                         if(i==l-1)
  986.                                         {
  987.                                             inputText[current_line]=sh;
  988.                                             mainTextTexture[current_line].loadFromRenderedText( inputText[current_line], textColor );
  989.                                         }
  990.                                         Ltemp.loadFromRenderedText( sh, textColor );
  991.                                         if(Ltemp.getWidth()>=SCREEN_WIDTH-100)
  992.                                         {
  993.                                        
  994.                                             inputText[current_line]=sh;
  995.                                             mainTextTexture[current_line].loadFromRenderedText( inputText[current_line], textColor );
  996.                                             current_line++;
  997.                                             total_line++;
  998.                                             inputText[total_line]="@";
  999.                                             for(int j=total_line;j>current_line+1;j--)
  1000.                                             {
  1001.                                                 sh=inputText[j];
  1002.                                                 inputText[j]=inputText[j-1];
  1003.                                                 inputText[j-1]=sh;
  1004.                                                 mainTextTexture[j].loadFromRenderedText( inputText[j], textColor );
  1005.                                             }
  1006.  
  1007.                                             for(int j=0;j<=count;j++)sh.pop_back();
  1008.  
  1009.  
  1010.                                             count=0;
  1011.                                             //inputText[current_line].pop_back();
  1012.  
  1013.  
  1014.                                         }
  1015.  
  1016.                                     }
  1017.  
  1018.                                  }
  1019.                                 else
  1020.                                 {
  1021.                                     inputText[current_line]=sh;
  1022.                                     mainTextTexture[current_line].loadFromRenderedText( inputText[current_line], textColor );
  1023.                                 }
  1024.                                 renderText=false;
  1025.                        
  1026.                         }
  1027.  
  1028.  
  1029.  
  1030.  
  1031.  
  1032.                         //newline
  1033.  
  1034.  
  1035.  
  1036.                          if( SDL_GetModState() & KMOD_CTRL )ctrl_count=1;
  1037.  
  1038.                         int width = mainTextTexture[current_line].getWidth();
  1039.                         if(width >= SCREEN_WIDTH-100&&ctrl_count!=1)
  1040.                         {
  1041.                            
  1042.                                if(backspace_check!=1)
  1043.                                {
  1044.  
  1045.                                 current_line++;
  1046.                  
  1047.                                 total_line++;
  1048.                                }
  1049.                                else
  1050.                                 backspace_check=0;
  1051.  
  1052.                                 renderText = true;
  1053.                          
  1054.  
  1055.                         }
  1056.                         else
  1057.                             ctrl_count=0;
  1058.  
  1059.  
  1060.  
  1061.  
  1062.                     }
  1063.  
  1064.  
  1065.  
  1066.  
  1067.  
  1068.  
  1069.                     else if( e.type == SDL_TEXTINPUT )
  1070.                     {
  1071.                         if( !( SDL_GetModState() & KMOD_CTRL && ( e.text.text[ 0 ] == 'c' || e.text.text[ 0 ] == 'C' || e.text.text[ 0 ] == 'v' || e.text.text[ 0 ] == 'V'|| e.text.text[ 0 ] == 'a' || e.text.text[ 0 ] == 'A' ) ) )
  1072.                         {
  1073.                             inputText[current_line] += e.text.text;
  1074.                             renderText = true;
  1075.                         }
  1076.                     }
  1077.  
  1078.  
  1079.  
  1080.  
  1081.  
  1082.  
  1083.                         //indicator
  1084.  
  1085.                      
  1086.  
  1087.                         length=strlen(inputText[current_line].c_str());
  1088.                         indi_xpos=length-left_sign;
  1089.                         if(indi_xpos<0)indi_xpos=0;
  1090.                  
  1091.                        
  1092.                         for(int i=0;i<=length;i++)
  1093.                         {
  1094.                             if(i<indi_xpos)ctemp[i]=inputText[current_line].c_str()[i];
  1095.                             stemp[i]=inputText[current_line].c_str()[i];
  1096.  
  1097.  
  1098.                         }
  1099.                         stemp[length+1]=0;
  1100.                         ctemp[indi_xpos]=0;
  1101.                         if(indi_xpos!=0)
  1102.                         {
  1103.                             Ltemp.loadFromRenderedText( ctemp, textColor );
  1104.                             final_indi_xpos=Ltemp.getWidth();
  1105.                         }
  1106.                         else
  1107.                             final_indi_xpos=0;
  1108.  
  1109.                         if(huda==1)
  1110.                         {
  1111.                             printf("l=%d ,ix=%d ,f_ix=%d ,ls=%d ,t_l=%d, c_l=%d\n",length,indi_xpos,final_indi_xpos,left_sign,total_line,current_line);
  1112.                          
  1113.                             huda=0;
  1114.                         }
  1115.  
  1116.  
  1117.                  
  1118.                   }
  1119.  
  1120.                
  1121.  
  1122.                     if( renderText )
  1123.                     {
  1124.  
  1125.                         if( inputText[current_line] != "" )
  1126.                         {
  1127.                             // //longer than window_width string
  1128.                             //  if(x!=0)
  1129.                             // {
  1130.                             //   x=0;
  1131.  
  1132.                             //     mainTextTexture[i].loadFromRenderedText( v[p], textColor );
  1133.  
  1134.                             // }
  1135.                          
  1136.  
  1137.  
  1138.                             //majhkhane kichu likhle
  1139.  
  1140.                             if(left_sign>=1)
  1141.                             {
  1142.                                
  1143.                                
  1144.                                 if(middle_backspace==0&&mainTextTexture[current_line].getWidth()<SCREEN_WIDTH-100)
  1145.                                 {
  1146.                                    
  1147.                                     //ekhane ken eta disi jani na eita dile majhe kichu likhe Thikmoto kaj kore na .....left_sign++;
  1148.                                     for(int i=length-1;i>indi_xpos-1;i--)
  1149.                                     {
  1150.                                         char_temp=stemp[i];
  1151.                                         stemp[i]=stemp[i-1];
  1152.                                         stemp[i-1]=char_temp;
  1153.                                    
  1154.  
  1155.                                     }
  1156.                                        
  1157.                                      
  1158.                                 }
  1159.                                 else
  1160.                                 {
  1161.                                    
  1162.                                     for(int i=indi_xpos-1;i<length-1;i++)
  1163.                                     {
  1164.                                         char_temp=stemp[i];
  1165.                                         stemp[i]=stemp[i+1];
  1166.                                         stemp[i+1]=char_temp;
  1167.                                    
  1168.  
  1169.                                     }
  1170.                                     //left_sign--;
  1171.  
  1172.                                 }
  1173.                                 for(int i=0;i<=length;i++)inputText[current_line].pop_back();
  1174.                             }
  1175.  
  1176.  
  1177.                             inputText[current_line]=stemp;
  1178.                             if(middle_backspace!=0)
  1179.                             {
  1180.                                 middle_backspace=0;
  1181.                                 inputText[current_line].pop_back();
  1182.  
  1183.                             }
  1184.                             //printf("%d\n",total_line);
  1185.  
  1186.  
  1187.  
  1188.                             mainTextTexture[current_line].loadFromRenderedText( inputText[current_line].c_str(), textColor );
  1189.                      
  1190.  
  1191.                         }
  1192.  
  1193.                         else
  1194.                         {
  1195.                             mainTextTexture[current_line].loadFromRenderedText( " ", textColor );
  1196.                         }
  1197.                     }
  1198.  
  1199.  
  1200.  
  1201.                     //enter dile space nibe
  1202.  
  1203.                     if(flag==1)
  1204.                     {
  1205.                         flag=0;
  1206.                         inputText[current_line-1] +="@";
  1207.                         mainTextTexture[current_line-1].loadFromRenderedText( "@", textColor );
  1208.                     }
  1209.                     max_line=SCREEN_HEIGHT/50-2;
  1210.                     if( total_line>max_line)scroll_count=total_line-max_line;
  1211.                     else
  1212.                         scroll_count=0;
  1213.                     if(current_line<=scroll_count&&total_line!=0)up_sign=scroll_count-current_line;
  1214.                     else
  1215.                         up_sign=0;
  1216.  
  1217.  
  1218.  
  1219.  
  1220.  
  1221.  
  1222.  
  1223.  
  1224.                     SDL_SetRenderDrawColor( main_renderer, 0x00, 0x00, 0x00, 0xFF );
  1225.                     SDL_RenderClear( main_renderer );
  1226.  
  1227.  
  1228.                  
  1229.                         //for blinking indicaotr
  1230.                         c++;
  1231.                         if(c%70>=32)
  1232.                         gDotTexture.render( final_indi_xpos,(current_line-scroll_count+up_sign)*50+50);
  1233.                         if(c>70)c=0;
  1234.                    
  1235.                
  1236.                     header.render( 0,0);
  1237.                     for(int j=0; j<=total_line-scroll_count; j++ )   mainTextTexture[j+scroll_count-up_sign].render( 0, j*50+ 50 );
  1238.  
  1239.                     SDL_RenderPresent( main_renderer );
  1240.                
  1241.  
  1242.  
  1243.             }
  1244.             SDL_StopTextInput();
  1245.  
  1246.         }
  1247.     }
  1248.     close();
  1249.     return 0;
  1250. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!