SHARE
TWEET

Untitled

a guest Oct 13th, 2019 168 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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 = 30;
  10. int day, month, year;
  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. void Dot::render()
  90. {
  91.     //Show the dot
  92.     gDotTexture.render( mPosX, mPosY );
  93. }
  94.  
  95.  
  96. bool init();
  97. bool loadMedia();
  98. void close();
  99.  
  100. SDL_Window* main_window = NULL;
  101. SDL_Renderer* main_renderer = NULL;
  102. TTF_Font* main_font=NULL;
  103. LTexture mainTextTexture[50];
  104. LTexture indi;
  105. LTexture header;
  106.  
  107. LTexture::LTexture()
  108. {
  109.     mTexture = NULL;
  110.     mWidth = 0;
  111.     mHeight = 0;
  112. }
  113.  
  114. LTexture::~LTexture()
  115. {
  116.     free();
  117. }
  118.  
  119. bool LTexture::loadFromFile(std:: string path)
  120. {
  121.     free();
  122.     SDL_Texture* newTexture = NULL;
  123.     SDL_Surface* loadedSurface = IMG_Load(path.c_str());
  124.     if(loadedSurface==NULL)
  125.     {
  126.         printf( "Unable to load image %s! SDL_image Error: %s\n", path.c_str(), IMG_GetError() );
  127.     }
  128.     else
  129.     {
  130.         SDL_SetColorKey(loadedSurface, SDL_TRUE, SDL_MapRGB(loadedSurface->format, 0, 0xFF, 0xFF));
  131.         newTexture = SDL_CreateTextureFromSurface(main_renderer, loadedSurface);
  132.         if( newTexture == NULL )  printf( "Unable to create texture from %s! SDL Error: %s\n", path.c_str(), SDL_GetError() );
  133.  
  134.         else
  135.         {
  136.             mWidth = loadedSurface->w;
  137.             mHeight = loadedSurface->h;
  138.         }
  139.         SDL_FreeSurface(loadedSurface);
  140.     }
  141.     mTexture = newTexture;
  142.     return mTexture !=NULL;
  143. }
  144.  
  145.  
  146. #if defined(_SDL_TTF_H) || defined(SDL_TTF_H)
  147. bool LTexture::loadFromRenderedText(std::string textureText, SDL_Color textColor)
  148. {
  149.  
  150.     free();
  151.  
  152.     SDL_Surface* textSurface = TTF_RenderText_Solid(main_font, textureText.c_str(), textColor);
  153.     if( textSurface == NULL ) printf( "Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError() );
  154.     else
  155.     {
  156.         mTexture = SDL_CreateTextureFromSurface(main_renderer, textSurface);
  157.         if(mTexture == NULL)    printf( "Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError() );
  158.         else
  159.         {
  160.             mWidth = textSurface->w;
  161.             mHeight = textSurface->h;
  162.         }
  163.         SDL_FreeSurface(textSurface);
  164.     }
  165.     return mTexture!=NULL;
  166. }
  167.  
  168. #endif
  169.  
  170. void LTexture::free()
  171. {
  172.     if(mTexture!=NULL)
  173.     {
  174.         SDL_DestroyTexture(mTexture);
  175.         mTexture = NULL;
  176.         mWidth = 0;
  177.         mHeight = 0;
  178.     }
  179. }
  180.  
  181.  
  182.  
  183.  
  184. void LTexture::setColor(Uint8 red, Uint8 green, Uint8 blue)
  185. {
  186.     SDL_SetTextureColorMod(mTexture, red, green, blue);
  187.  
  188. }
  189.  
  190. void LTexture::setBlendMode(SDL_BlendMode blending)
  191. {
  192.     SDL_SetTextureBlendMode(mTexture, blending);
  193. }
  194.  
  195. void LTexture::setAlpha(Uint8 alpha)
  196. {
  197.     SDL_SetTextureAlphaMod(mTexture, alpha);
  198. }
  199.  
  200. void LTexture::render(int x, int y, SDL_Rect* clip, double angle, SDL_Point* center, SDL_RendererFlip flip)
  201. {
  202.     SDL_Rect renderQuad = {x,y,mWidth,mHeight};
  203.     if(clip!=NULL)
  204.     {
  205.         renderQuad.w = clip->w;
  206.         renderQuad.h = clip->h;
  207.     }
  208.     SDL_RenderCopyEx(main_renderer, mTexture, clip, &renderQuad, angle, center, flip);
  209. }
  210.  
  211.  
  212. int LTexture::getWidth()
  213. {
  214.     return mWidth;
  215. }
  216.  
  217. int LTexture::getHeight()
  218. {
  219.     return mHeight;
  220. }
  221.  
  222. bool init()
  223. {
  224.     bool success = true;
  225.     if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  226.     {
  227.         printf( "SDL could not initialize! SDL Error: %s\n", SDL_GetError() );
  228.         success = false;
  229.     }
  230.     else
  231.     {
  232.         if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY,"1")) printf("Warning: Linear texture filtering not enabled!" );
  233.         main_window = SDL_CreateWindow("PASA",0,0,SCREEN_WIDTH,SCREEN_HEIGHT,SDL_WINDOW_SHOWN);
  234.         if(main_window==NULL)
  235.         {
  236.             printf( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
  237.             success = false;
  238.         }
  239.         else
  240.         {
  241.             main_renderer = SDL_CreateRenderer(main_window,-1,SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
  242.             if( main_renderer == NULL )
  243.             {
  244.                 printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
  245.                 success = false;
  246.             }
  247.             else
  248.             {
  249.                 SDL_SetRenderDrawColor(main_renderer, 0xFF,0xFF,0xFF,0xFF);
  250.                 int imgFlags = IMG_INIT_PNG;
  251.                 if(!(IMG_Init(imgFlags)&imgFlags))
  252.                 {
  253.                     printf( "SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError() );
  254.                     success = false;
  255.                 }
  256.                 if( TTF_Init() == -1 )
  257.                 {
  258.                     printf( "SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError() );
  259.                     success = false;
  260.                 }
  261.             }
  262.         }
  263.     }
  264.     return success;
  265. }
  266.  
  267. bool loadMedia()
  268. {
  269.     bool success = true;
  270.  
  271.     main_font = TTF_OpenFont("boy.ttf", Font_WIDTH);
  272.     if(main_font==NULL)
  273.     {
  274.         printf( "Failed to load font! SDL_ttf Error: %s\n", TTF_GetError() );
  275.         success = false;
  276.     }
  277.     else
  278.     {
  279.         SDL_Color hColor = {0xD3,0xFF,0xCE};
  280.         if(!header.loadFromRenderedText(date,hColor))
  281.         {
  282.             printf( "Failed to render text texture!\n" );
  283.             success = false;
  284.         }
  285.     }
  286.     //Load dot texture
  287.     if( !gDotTexture.loadFromFile( "indi.png" ) )
  288.     {
  289.         printf( "Failed to load dot texture!\n" );
  290.         success = false;
  291.     }
  292.  
  293.     return success;
  294. }
  295.  
  296. void close()
  297. {
  298.     for(int i=0; i<50; i++)
  299.     {
  300.         mainTextTexture[i].free();
  301.     }
  302.     gDotTexture.free();
  303.     header.free();
  304.     TTF_CloseFont(main_font);
  305.     main_font = NULL;
  306.     SDL_DestroyRenderer(main_renderer);
  307.     main_renderer = NULL;
  308.     SDL_DestroyWindow(main_window);
  309.  
  310.     main_window = NULL;
  311.     TTF_Quit();
  312.     IMG_Quit();
  313.     SDL_Quit();
  314. }
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.  
  338.  
  339.  
  340. int main(int argn, char* args[])
  341. {
  342.  
  343.     int i = 0,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;
  344.     int left_sign=0,tchar[i]={0};
  345.     char s[1001000],v[100][2002];
  346.  
  347.  
  348.     // printf("ENTER DATE. In format 11 10 2019!\n");
  349.     // scanf("%d %d %d", &day, &month, &year);
  350.     // if(month==1) sprintf(date, "%d th January, %d", day, year);
  351.     // else if(month==2) sprintf(date, "%d th February, %d", day, year);
  352.     // else if(month==3) sprintf(date, "%d th March, %d", day, year);
  353.     // else if(month==4) sprintf(date, "%d th April, %d", day, year);
  354.     // else if(month==5) sprintf(date, "%d th May, %d", day, year);
  355.     // else if(month==6) sprintf(date, "%d th June, %d", day, year);
  356.     // else if(month==7) sprintf(date, "%d th July, %d", day, year);
  357.     // else if(month==8) sprintf(date, "%d th August, %d", day, year);
  358.     // else if(month==9) sprintf(date, "%d th September, %d", day, year);
  359.     // else if(month==10) sprintf(date, "%d th October, %d", day, year);
  360.     // else if(month==11) sprintf(date, "%d th Novermber, %d", day, year);
  361.     sprintf(date, "%d th December, %d", day, year);
  362.  
  363.  
  364.     if(!init()) printf("Failed to initialize/n");
  365.     else
  366.     {
  367.         if(!loadMedia()) printf("Failed to load media\n");
  368.         else
  369.         {
  370.  
  371.             bool quit = false;
  372.             SDL_Event e;
  373.             SDL_Color textColor = {0xFF,0xFF,0xFF};
  374.             std::string inputText[50];
  375.             std::string copyText[50];
  376.             std::string sh;
  377.             //for(int k=0; k<50; k++) inputText[k] = "";
  378.             Dot dot;
  379.             SDL_StartTextInput();
  380.             while(!quit)
  381.             {
  382.                 bool renderText = false;
  383.  
  384.                 while(SDL_PollEvent(&e)!=0)
  385.                 {
  386.  
  387.                     if(e.type == SDL_QUIT) quit = true;
  388.  
  389.  
  390.                     else if(e.type == SDL_KEYDOWN)
  391.                     {
  392.                        
  393.  
  394.  
  395.  
  396.  
  397.                         //backspace key
  398.  
  399.  
  400.  
  401.  
  402.  
  403.                         if( e.key.keysym.sym == SDLK_BACKSPACE )
  404.                         {
  405.                             i=current_line;
  406.  
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.                             //backspace main part
  414.  
  415.  
  416.  
  417.                             if(inputText[i].length()==0&&current_line!=0)
  418.                             {
  419.  
  420.                              
  421.                                 //majher ekta line kaatle
  422.  
  423.  
  424.                                 if(current_line<total_line)
  425.                                 {
  426.                                   for(int a=0;a<total_line-current_line;a++)
  427.                                   {
  428.                                     sh=inputText[i+a];
  429.                                     inputText[i+a]=inputText[i+1+a];
  430.                                     inputText[i+1+a]=sh;
  431.                                     mainTextTexture[i+a].loadFromRenderedText( inputText[i+a].c_str(), textColor );
  432.                                   }
  433.                                 }
  434.  
  435.                                 total_line--;
  436.                                 current_line--;
  437.                                 i=current_line;
  438.                                 left_sign=0;
  439.                                
  440.  
  441.  
  442.  
  443.                                 if(mainTextTexture[i].getWidth()>=SCREEN_WIDTH-100) inputText[i].pop_back();
  444.                                 renderText = false;
  445.                                 mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  446.                             }
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.  
  457.                             else if(inputText[i].length() > 0)
  458.                             {
  459.                                 inputText[i].pop_back();
  460.                                 renderText = true;
  461.                             }
  462.                         }
  463.  
  464.  
  465.  
  466.  
  467.  
  468.                         //Up key
  469.  
  470.  
  471.  
  472.                         else if( e.key.keysym.sym == SDLK_UP )
  473.                         {
  474.                            
  475.                          
  476.  
  477.                             if(current_line>0)
  478.                            
  479.                           {
  480.                             left_sign=0;
  481.                             if(mainTextTexture[i-1].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  482.                             current_line--;
  483.                             i=current_line;
  484.                             renderText=true;
  485.  
  486.                           }
  487.                             else
  488.                             {
  489.                                 i=0;
  490.                                 renderText = true;
  491.                             }
  492.                         }
  493.  
  494.  
  495.  
  496.  
  497.  
  498.  
  499.                         //down key
  500.  
  501.  
  502.  
  503.                         else if( e.key.keysym.sym == SDLK_DOWN &&inputText[i].length()>0)
  504.                         {
  505.                            
  506.                             if(current_line<total_line)
  507.                             {
  508.                                 left_sign=0;
  509.                                 if(mainTextTexture[i+1].getWidth()>=SCREEN_WIDTH-100)backspace_check=1;
  510.                                 x--;
  511.                                 current_line++;
  512.                                 i=current_line;
  513.                                
  514.                             }
  515.  
  516.  
  517.  
  518.                             renderText = true;
  519.                         }
  520.                                 //right key
  521.  
  522.                         else if( e.key.keysym.sym == SDLK_RIGHT &&side_count<length)
  523.                         {
  524.                            
  525.                           if(left_sign>0)left_sign--;
  526.                         }
  527.  
  528.                             //left key
  529.                           else if( e.key.keysym.sym == SDLK_LEFT )
  530.                         {
  531.                            
  532.                          
  533.                             if(left_sign==0)left_sign+=2;
  534.                             else
  535.                                 left_sign++;
  536.                            
  537.                         }
  538.  
  539.  
  540.  
  541.  
  542.                         //enter key
  543.  
  544.  
  545.  
  546.                         if( e.key.keysym.sym == SDLK_RETURN)
  547.                         {
  548.                             current_line++;
  549.                             total_line++;
  550.                             left_sign=0;
  551.                          
  552.  
  553.                             i=current_line;
  554.                            //jani na jhamela badhle dekhbo c++;
  555.                             if(inputText[i-1].length()==0)flag=1;
  556.                             //mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  557.  
  558.  
  559.                             renderText = false;
  560.                         }
  561.  
  562.  
  563.  
  564.  
  565.  
  566.  
  567.  
  568.  
  569.  
  570.  
  571.  
  572.                         int width = mainTextTexture[i].getWidth();
  573.                         if(width >= SCREEN_WIDTH-100)
  574.                         {
  575.                            if(backspace_check!=1)
  576.                            {
  577.  
  578.                             current_line++;
  579.                             i=current_line;
  580.                             total_line++;
  581.                            }
  582.                            else
  583.                             backspace_check=0;
  584.  
  585.                             renderText = true;
  586.                         }
  587.  
  588.                         //copy something
  589.  
  590.                         else if( e.key.keysym.sym == SDLK_c && SDL_GetModState() & KMOD_CTRL )
  591.                         {
  592.                             for(int bal=0; bal<=i; bal++)
  593.                             {
  594.                                 strcat(s,inputText[bal].c_str());
  595.                                 if(bal!=i)strcat(s,"\n");
  596.  
  597.  
  598.  
  599.                             }
  600.                             SDL_SetClipboardText(s);
  601.                             s[0]=0;
  602.                         }
  603.  
  604.                         //paste something
  605.  
  606.  
  607.                         else if( e.key.keysym.sym == SDLK_v && SDL_GetModState() & KMOD_CTRL )
  608.                         {
  609.  
  610.  
  611.  
  612.                             inputText[i] = inputText[i]+SDL_GetClipboardText();
  613.                             // int l=strlen(inputText[i].c_str());
  614.  
  615.                             // if(l*Font_WIDTH>=SCREEN_WIDTH-100)
  616.                             // {
  617.  
  618.                             // for(int j=0;j<l;j++)s[j]=SDL_GetClipboardText()[j];
  619.  
  620.                             //   for(p=0;p<100;p++)
  621.                             //   {
  622.                             //     for(q=0;q<2*(SCREEN_WIDTH-100)/Font_WIDTH;q++)
  623.                             //     {
  624.                             //       if(count>=l)
  625.                             //       {
  626.                             //         break;
  627.                             //           x=1;
  628.                             //       }
  629.  
  630.                             //       if(s[count]=='\n')break;
  631.  
  632.                             //       else
  633.                             //       {
  634.                             //         v[p][q]=s[count];
  635.                             //       }
  636.                             //       count++;
  637.                             //     }
  638.                             //     if(x==1)
  639.                             //     {
  640.                             //       break;
  641.                             //     }
  642.                             //     i++;
  643.  
  644.                             //       mainTextTexture[i].loadFromRenderedText( v[p], textColor );
  645.                             //         SDL_SetRenderDrawColor( main_renderer, 0x00, 0x00, 0x00, 0xFF );
  646.                             //      SDL_RenderClear( main_renderer );
  647.                             //      header.render( 0,0);
  648.                             //    for(int j=0; j<=i; j++ )  mainTextTexture[j].render( 0, j*50+ 50 );
  649.  
  650.                             //     SDL_RenderPresent( main_renderer );
  651.  
  652.                             //   }
  653.  
  654.                             //   count=0;
  655.                             //    renderText = false;
  656.                             //  }
  657.                             //  else
  658.                             renderText = true;
  659.                             z=1;
  660.  
  661.  
  662.                         }
  663.  
  664.                         length=strlen(inputText[i].c_str());
  665.                  
  666.                         printf("%d %d %d\n",length,length-left_sign,tchar[i] );
  667.  
  668.                     }
  669.  
  670.                     else if( e.type == SDL_TEXTINPUT )
  671.                     {
  672.                         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' ) ) )
  673.                         {
  674.                             inputText[i] += e.text.text;
  675.                             renderText = true;
  676.                         }
  677.                     }
  678.                  
  679.                   }
  680.  
  681.                
  682.  
  683.                     if( renderText )
  684.                     {
  685.  
  686.                         if( inputText[i] != "" )
  687.                         {
  688.                             // //longer than window_width string
  689.                             //  if(x!=0)
  690.                             // {
  691.                             //   x=0;
  692.  
  693.                             //     mainTextTexture[i].loadFromRenderedText( v[p], textColor );
  694.  
  695.                             // }
  696.  
  697.  
  698.  
  699.                             mainTextTexture[i].loadFromRenderedText( inputText[i].c_str(), textColor );
  700.                             //copy paste
  701.                             if(z==1)
  702.                             {
  703.                                 i++;
  704.                                 current_line++;
  705.                                 total_line++;
  706.                                 z=0;
  707.                             }
  708.  
  709.  
  710.                         }
  711.  
  712.                         else
  713.                         {
  714.                             mainTextTexture[i].loadFromRenderedText( " ", textColor );
  715.                         }
  716.                     }
  717.  
  718.  
  719.  
  720.                     //enter dile space nibe
  721.  
  722.                     if(flag==1)
  723.                     {
  724.                         flag=0;
  725.                         inputText[i-1] +="@";
  726.                         mainTextTexture[i-1].loadFromRenderedText( "@", textColor );
  727.                     }
  728.                    // printf("%d\n",mainTextTexture[i].getWidth() );
  729.  
  730.                     SDL_SetRenderDrawColor( main_renderer, 0x00, 0x00, 0x00, 0xFF );
  731.                     SDL_RenderClear( main_renderer );
  732.                     //for blinking indicaotr
  733.                     c++;
  734.                     if(c%60>=25)
  735.                     gDotTexture.render(mainTextTexture[i].getWidth(),current_line*50+50);
  736.                     if(c>60)c=0;
  737.                     header.render( 0,0);
  738.                     for(int j=0; j<=total_line; j++ )   mainTextTexture[j].render( 0, j*50+ 50 );
  739.  
  740.                     SDL_RenderPresent( main_renderer );
  741.                
  742.  
  743.  
  744.             }
  745.             SDL_StopTextInput();
  746.  
  747.         }
  748.     }
  749.     close();
  750.     return 0;
  751. }
RAW Paste Data
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
 
Top