API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 3rd, 2017
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 80.36 KB | None | 0 0
raw download clone embed print report
  1. #include <gtk/gtk.h>
  2. #include <stdlib.h>
  3. #include <sys/types.h>
  4. #include <sys/socket.h>
  5. #include <netinet/in.h>
  6. #include <errno.h>
  7. #include <unistd.h>
  8. #include <stdio.h>
  9. #include <netdb.h>
  10. #include <string.h>
  11.  
  12. extern int errno;
  13. int sd;
  14.  
  15. static void inregistrare_admin(GtkButton *button, gpointer menu);
  16. static void login_admin(GtkButton *button, gpointer menu);
  17. static void inregistrare_utilizator(GtkButton *button, gpointer menu);
  18. static void logare_utilizator(GtkButton *button, gpointer menu);
  19. static void quit_out(GtkButton *button, gpointer menu);
  20. static void on_renunta(GtkButton *button, gpointer menu);
  21.  
  22. static void quit_meniu(GtkButton *button, gpointer menu)
  23. {
  24. GtkWidget *parent = menu;
  25. int size_comm = strlen("quit");
  26. if(write(sd, &size_comm, sizeof(int)) <= 0)
  27. {
  28. perror("Eroare la scriere catre server");
  29. return errno;
  30. }
  31. if(write(sd, "quit", size_comm) <= 0)
  32. {
  33. perror("Eroare la scriere catre server");
  34. return errno;
  35. }
  36. // close(sd);
  37. }
  38.  
  39. static void on_continua_top(GtkButton *button, GObject *context_object)
  40. {
  41. GtkWindow *parent = g_object_get_data(context_object, "parent");
  42. GtkEntry *entry = g_object_get_data(context_object, "entry");
  43.  
  44. char *nume = gtk_entry_get_text(entry);
  45. int ok = 1;
  46. if(strlen(nume) == 0)
  47. ok = 0;
  48.  
  49. if(ok)
  50. {
  51. int size_nume = strlen(nume);
  52. if(write(sd, &size_nume, sizeof(int)) <= 0)
  53. {
  54. perror("Eroare la write() catre server");
  55. return errno;
  56. }
  57. if(write(sd, nume, size_nume) <= 0)
  58. {
  59. perror("Eroare la write() catre server");
  60. return errno;
  61. }
  62.  
  63. int ex = 0;
  64. if(read(sd, &ex, sizeof(int)) <= 0)
  65. {
  66. perror("Eroare la read() de la server");
  67. return errno;
  68. }
  69. if(ex == 0)
  70. {
  71. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  72. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Genul nu exista!");
  73. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  74. gtk_dialog_run(GTK_DIALOG(warning));
  75. gtk_widget_destroy(warning);
  76. }else{
  77. char matrix[100][100];
  78. bzero(matrix, sizeof(matrix));
  79. if(read(sd, matrix, sizeof(matrix)) <= 0)
  80. {
  81. perror("Eroare la read de la server");
  82. return errno;
  83. }
  84.  
  85. char text[1000];
  86. bzero(text, 1000);
  87. strcat(text, "Topul pentru genul ");
  88. strcat(text, nume);
  89. strcat(text, " este:\n");
  90. for(int i = 0; i < 100; i++)
  91. {
  92. if(strlen(matrix[i]) == 0)
  93. continue;
  94. strcat(text, matrix[i]);
  95. strcat(text, "\n");
  96. }
  97.  
  98. GtkWindow *new_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  99. g_signal_connect(new_window, "delete-event", G_CALLBACK(quit_meniu), new_window);
  100. gtk_window_set_default_size(GTK_WINDOW(new_window), 400, 200);
  101. gtk_window_set_title(GTK_WINDOW(new_window), nume);
  102. GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  103. gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
  104. GtkWidget *label = gtk_label_new(text);
  105. gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), label);
  106. gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  107. gtk_container_add (GTK_CONTAINER (new_window), scrolled_window);
  108. gtk_widget_destroy(parent);
  109. gtk_widget_show_all(new_window);
  110. }
  111.  
  112.  
  113. }
  114. }
  115.  
  116. static void top_pe_genuri(GtkButton *button, gpointer menu)
  117. {
  118. GtkWindow *parent = menu;
  119. GtkWindow *top = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  120.  
  121. gtk_window_set_title(GTK_WINDOW(top), "Top pe genuri");
  122. gtk_window_set_default_size(GTK_WINDOW(top), 400, 200);
  123.  
  124. int size_comm = strlen("top_pe_genuri");
  125. if(write(sd, &size_comm, sizeof(int)) <= 0)
  126. {
  127. perror("Eroare la write() catre server");
  128. return errno;
  129. }
  130. if(write(sd, "top_pe_genuri", size_comm) <= 0)
  131. {
  132. perror("Eroare la write() catre server");
  133. return errno;
  134. }
  135.  
  136. char matrix[100][100];
  137. bzero(matrix, sizeof(matrix));
  138.  
  139. if(read(sd, matrix, sizeof(matrix)) <= 0)
  140. {
  141. perror("Eroare la read() de la server");
  142. return errno;
  143. }
  144.  
  145. char text[1000];
  146. bzero(text, 1000);
  147. strcat(text, "Poti vedea topul pentru urmatoarele genuri:\n");
  148. for(int i = 0; i < 100; i++)
  149. {
  150. if(strlen(matrix[i]) == 0)
  151. continue;
  152. strcat(text, matrix[i]);
  153. strcat(text, "\n");
  154. }
  155.  
  156. GtkWidget *box;
  157. box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  158. GtkWidget *label = gtk_label_new(text);
  159. GtkWidget *entry = gtk_entry_new();
  160. GtkWidget *continua = gtk_button_new_with_label("Continua");
  161. GtkWidget *renunta = gtk_button_new_with_label("Renunta");
  162. GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  163. GtkWidget *label_gen = gtk_label_new("Introdu genul:");
  164. GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  165. GtkWidget *hhbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  166. gtk_box_pack_start(GTK_BOX(hhbox), label_gen, TRUE, TRUE, 10);
  167. gtk_box_pack_start(GTK_BOX(hhbox), entry, TRUE, TRUE, 10);
  168. gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 10);
  169. gtk_box_pack_start(GTK_BOX(box), scrolled_window, TRUE, TRUE, 10);
  170. gtk_box_pack_start(GTK_BOX(box), hhbox, TRUE, TRUE, 10);
  171. gtk_box_pack_start(GTK_BOX(hbox), renunta, TRUE, TRUE, 10);
  172. gtk_box_pack_start(GTK_BOX(hbox), continua, TRUE, TRUE, 10);
  173. gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 10);
  174.  
  175. gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
  176. gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  177. gtk_container_add (GTK_CONTAINER (top), box);
  178.  
  179. g_object_set_data(G_OBJECT(continua), "parent", top);
  180. g_object_set_data(G_OBJECT(continua), "entry", entry);
  181.  
  182. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), top);
  183. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_top), continua);
  184.  
  185. gtk_widget_show_all(top);
  186. }
  187.  
  188. static void on_continua_cauta_melodie(GtkButton *button, GObject *context_object)
  189. {
  190. GtkWindow *parent = g_object_get_data(context_object, "parent");
  191. GtkEntry *entry = g_object_get_data(context_object, "entry");
  192.  
  193. char *nume = gtk_entry_get_text(entry);
  194. int ok = 1;
  195. if(strlen(nume) == 0)
  196. ok = 0;
  197. if(ok == 1)
  198. {
  199. int size_comm = strlen("cauta_melodie");
  200. if(write(sd, &size_comm, sizeof(int)) <= 0)
  201. {
  202. perror("Eroare la write catre server");
  203. return errno;
  204. }
  205. if(write(sd, "cauta_melodie", size_comm) <= 0)
  206. {
  207. perror("Eroare la write catre server");
  208. return errno;
  209. }
  210. int size_nume = strlen(nume);
  211. if(write(sd, &size_nume, sizeof(int)) <= 0)
  212. {
  213. perror("Eroare la write catre server");
  214. return errno;
  215. }
  216. if(write(sd, nume, size_nume) <= 0)
  217. {
  218. perror("Eroare la write catre server");
  219. return errno;
  220. }
  221.  
  222. int exists = 0;
  223. if(read(sd, &exists, sizeof(int)) <= 0)
  224. {
  225. perror("Eroare la read de la server");
  226. return errno;
  227. }
  228. if(exists == 0)
  229. {
  230. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  231. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodia nu exista!");
  232. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  233. gtk_dialog_run(GTK_DIALOG(warning));
  234. gtk_widget_destroy(warning);
  235. }else{
  236. char rating[100];
  237. bzero(rating, 100);
  238. if(read(sd, rating, 100) <= 0)
  239. {
  240. perror("Eroare la read() de la server");
  241. return errno;
  242. }
  243. char comentarii[100][100];
  244. bzero(comentarii, sizeof(comentarii));
  245.  
  246. if(read(sd, comentarii, sizeof(comentarii)) <= 0)
  247. {
  248. perror("Eroare la read() de la server");
  249. return errno;
  250. }
  251.  
  252. char text[1000];
  253. bzero(text, 1000);
  254.  
  255. strcat(text, nume);
  256. strcat(text, " are ratingul: ");
  257. strcat(text, rating);
  258. strcat(text, "\n\n\n");
  259.  
  260. for(int i = 0; i < 100; i++)
  261. {
  262. if(strlen(comentarii[i]) == 0)
  263. continue;
  264. strcat(text, comentarii[i]);
  265. strcat(text,"\n\n");
  266. }
  267.  
  268. GtkWidget *label = gtk_label_new(text);
  269. GtkWidget *new_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  270. gtk_window_set_title(GTK_WINDOW(new_window), nume);
  271. gtk_window_set_default_size(GTK_WINDOW(new_window), 400, 200);
  272.  
  273. gtk_widget_destroy(GTK_WIDGET(parent));
  274. GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  275. gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
  276.  
  277. gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), label);
  278. gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  279. gtk_container_add (GTK_CONTAINER (new_window), scrolled_window);
  280.  
  281. gtk_widget_show_all(new_window);
  282. }
  283. }
  284.  
  285. }
  286.  
  287. static void on_cauta_melodie(GtkButton *button, gpointer menu)
  288. {
  289. GtkWindow *parent = menu;
  290. GtkWidget *cauta_melodie = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  291. gtk_window_set_title(GTK_WINDOW(cauta_melodie), "Cauta o melodie");
  292. gtk_window_set_default_size(GTK_WINDOW(cauta_melodie), 400, 200);
  293.  
  294. GtkWidget *entry, *label, *continua, *renunta;
  295. entry = gtk_entry_new();
  296. label = gtk_label_new("Introdu numele aici: ");
  297. continua = gtk_button_new_with_label("Continua");
  298. renunta = gtk_button_new_with_label("Renunta");
  299.  
  300. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  301.  
  302. gtk_layout_put(GTK_LAYOUT(layout), label,10, 30);
  303. gtk_layout_put(GTK_LAYOUT(layout), entry, 200, 25);
  304. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 110);
  305. gtk_layout_put(GTK_LAYOUT(layout), renunta,10, 110);
  306.  
  307. g_object_set_data(G_OBJECT(continua), "parent", cauta_melodie);
  308. g_object_set_data(G_OBJECT(continua), "entry", entry);
  309. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), cauta_melodie);
  310. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_cauta_melodie), continua);
  311.  
  312. gtk_container_add(GTK_CONTAINER(cauta_melodie), layout);
  313.  
  314. gtk_widget_show_all(cauta_melodie);
  315.  
  316. }
  317.  
  318. static void on_continua_adauga_comentariu(GtkButton *button, GObject *context_object)
  319. {
  320. GtkWindow *parent = g_object_get_data(context_object, "parent");
  321. GtkEntry *entry_nume = g_object_get_data(context_object, "entry_nume");
  322. GtkEntry *entry_comm = g_object_get_data(context_object, "entry_comm");
  323.  
  324. char *nume, *comm;
  325. nume = gtk_entry_get_text(entry_nume);
  326. comm = gtk_entry_get_text(entry_comm);
  327. int ok = 1;
  328. if(strlen(nume) == 0 || strlen(comm) == 0)
  329. {
  330. ok = 0;
  331. }
  332. if(ok == 1)
  333. {
  334. int size_comm = strlen("adauga_comentariu");
  335. if(write(sd, &size_comm, sizeof(int)) <= 0)
  336. {
  337. perror("Eroare la write catre server");
  338. return errno;
  339. }
  340. if(write(sd, "adauga_comentariu", size_comm) <= 0)
  341. {
  342. perror("Eroare la write catre server");
  343. return errno;
  344. }
  345.  
  346. int size_nume = strlen(nume);
  347. if(write(sd, &size_nume, sizeof(int)) <= 0)
  348. {
  349. perror("Eroare la write catre server");
  350. return errno;
  351. }
  352. if(write(sd, nume, size_nume) <= 0)
  353. {
  354. perror("Eroare la write catre server!");
  355. return errno;
  356. }
  357. int size_c = strlen(comm);
  358. if(write(sd, &size_c, sizeof(int)) <= 0)
  359. {
  360. perror("Eroare la write catre server");
  361. return errno;
  362. }
  363. if(write(sd, comm, size_c) <= 0)
  364. {
  365. perror("Eroare la write catre server");
  366. return errno;
  367. }
  368.  
  369. int ex = 0;
  370. if(read(sd, &ex, sizeof(int)) <= 0)
  371. {
  372. perror("Eroare la write catre server");
  373. return errno;
  374. }
  375. if(ex == 0)
  376. {
  377. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  378. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodia nu exista!");
  379. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  380. gtk_dialog_run(GTK_DIALOG(warning));
  381. gtk_widget_destroy(warning);
  382. }
  383. else{
  384.  
  385. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  386. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Comentariu adaugat cu succes!");
  387. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  388. gtk_dialog_run(GTK_DIALOG(warning));
  389. gtk_widget_destroy(warning);
  390. }
  391. }
  392. }
  393.  
  394. static void on_adauga_comm(GtkButton *button, gpointer menu)
  395. {
  396. GtkWindow *parent = menu;
  397. GtkWidget *adauga_comentariu = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  398. gtk_window_set_title(GTK_WINDOW(adauga_comentariu), "Adauga comentariu");
  399. gtk_window_set_default_size(GTK_WINDOW(adauga_comentariu), 400, 200);
  400.  
  401. GtkWidget *entry_nume, *entry_comentariu, *label_nume, *label_comentariu, *continua, *renunta;
  402. entry_nume = gtk_entry_new();
  403. entry_comentariu = gtk_entry_new();
  404. label_nume = gtk_label_new("Introdu numele melodiei :");
  405. label_comentariu = gtk_label_new("Introdu comentariul :");
  406. continua = gtk_button_new_with_label("Continua");
  407. renunta = gtk_button_new_with_label("Renunta");
  408.  
  409. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  410. gtk_layout_put(GTK_LAYOUT(layout), label_nume, 10, 30);
  411. gtk_layout_put(GTK_LAYOUT(layout), entry_nume, 200, 25);
  412. gtk_layout_put(GTK_LAYOUT(layout), label_comentariu, 10, 70);
  413. gtk_layout_put(GTK_LAYOUT(layout), entry_comentariu, 200, 65);
  414. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 110);
  415. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 110);
  416.  
  417. g_object_set_data(G_OBJECT(continua), "parent", adauga_comentariu);
  418. g_object_set_data(G_OBJECT(continua), "entry_nume", entry_nume);
  419. g_object_set_data(G_OBJECT(continua), "entry_comm", entry_comentariu);
  420.  
  421. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), adauga_comentariu);
  422. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_adauga_comentariu), continua);
  423.  
  424. gtk_container_add(GTK_CONTAINER(adauga_comentariu), layout);
  425. gtk_widget_show_all(adauga_comentariu);
  426. }
  427.  
  428. static void top_general(GtkButton *button, gpointer menu)
  429. {
  430. GtkWindow *parent = menu;
  431. GtkWidget *top = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  432. gtk_window_set_title(GTK_WINDOW(top), "Top General");
  433. gtk_window_set_default_size(GTK_WINDOW(top), 400, 300);
  434.  
  435. int size_comm = strlen("top_general");
  436. if(write(sd, &size_comm, sizeof(int)) <= 0)
  437. {
  438. perror("Eroare la write catre server!");
  439. return errno;
  440. }
  441. if(write(sd, "top_general", size_comm) <= 0)
  442. {
  443. perror("Eroare la write catre server!");
  444. return errno;
  445. }
  446.  
  447. char rez[100][100];
  448. bzero(rez, sizeof(rez));
  449.  
  450. if(read(sd, rez, sizeof(rez)) <= 0)
  451. {
  452. perror("Eroare la read() de la server");
  453. return errno;
  454. }
  455.  
  456. char labell[10000];
  457. bzero(labell, 10000);
  458.  
  459. strcat(labell, "Top general : \n");
  460. for(int i = 0; i < 100; i++)
  461. {
  462. if(strlen(rez[i]) == 0)
  463. continue;
  464. strcat(labell, rez[i]);
  465. strcat(labell, "\n");
  466. }
  467.  
  468. GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  469. gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
  470. GtkWidget *label = gtk_label_new(labell);
  471. gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), label);
  472. gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  473. gtk_container_add (GTK_CONTAINER (top), scrolled_window);
  474.  
  475. gtk_widget_show_all(top);
  476. }
  477.  
  478. static void on_continua_voteaza_melodie(GtkButton *button, GObject *context_object)
  479. {
  480. GtkWindow *parent, *entry;
  481. parent = g_object_get_data(context_object, "parent");
  482. entry = g_object_get_data(context_object, "entry");
  483.  
  484. char *nume = gtk_entry_get_text(entry);
  485. int ok = 1;
  486. if(strlen(nume) == 0)
  487. ok = 0;
  488. if(ok == 1)
  489. {
  490. int size_comm = strlen("voteaza_melodie");
  491. if(write(sd, &size_comm, sizeof(int)) <= 0)
  492. {
  493. perror("Eroare la write() catre server");
  494. return errno;
  495. }
  496. if(write(sd, "voteaza_melodie", size_comm) <= 0)
  497. {
  498. perror("Eroare la write() catre server");
  499. return errno;
  500. }
  501.  
  502. int size_nume = strlen(nume);
  503. if(write(sd, &size_nume, sizeof(int)) <= 0)
  504. {
  505. perror("Eroare la write() catre server");
  506. return errno;
  507. }
  508. if(write(sd, nume, size_nume) <= 0)
  509. {
  510. perror("Eroare la write() catre server!");
  511. return errno;
  512. }
  513.  
  514. int exists = 0;
  515. if(read(sd, &exists, sizeof(int)) <= 0)
  516. {
  517. perror("Eroare la write() catre server");
  518. return errno;
  519. }
  520. if(exists == 0)
  521. {
  522. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  523. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodia nu exista!");
  524. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  525. gtk_dialog_run(GTK_DIALOG(warning));
  526. gtk_widget_destroy(warning);
  527. }
  528. else{
  529. int can_vote = 0;
  530. if(read(sd, &can_vote, sizeof(int)) <= 0)
  531. {
  532. perror("Eroare la read() de la server!");
  533. return errno;
  534. }
  535. if(can_vote == 0)
  536. {
  537. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  538. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Nu ai drept de vot!");
  539. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  540. gtk_dialog_run(GTK_DIALOG(warning));
  541. gtk_widget_destroy(warning);
  542. }
  543. else{
  544. int vot = 0;
  545. if(read(sd, &vot, sizeof(int)) <= 0)
  546. {
  547. perror("Eroare la read() de la server");
  548. return errno;
  549. }
  550. if(vot == 1)
  551. {
  552. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  553. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Ai votat deja pentru aceasta melodie!");
  554. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  555. gtk_dialog_run(GTK_DIALOG(warning));
  556. gtk_widget_destroy(warning);
  557. }else{
  558. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  559. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Votul tau a fost inregistrat cu succes!");
  560. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  561. gtk_dialog_run(GTK_DIALOG(warning));
  562. gtk_widget_destroy(warning);
  563. }
  564. }
  565. }
  566. }
  567. }
  568.  
  569. static void on_voteaza_melodie(GtkButton *button, gpointer menu)
  570. {
  571. GtkWindow *parent = menu;
  572. GtkWidget *voteaza_melodie, *label, *entry, *continua, *renunta;
  573. voteaza_melodie = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  574. gtk_window_set_title(GTK_WINDOW(voteaza_melodie), "Voteaza o melodie");
  575. gtk_window_set_default_size(GTK_WINDOW(voteaza_melodie), 400, 200);
  576. label = gtk_label_new("Introdu numele melodiei: ");
  577. entry = gtk_entry_new();
  578. continua = gtk_button_new_with_label("Continua");
  579. renunta = gtk_button_new_with_label("Renunta");
  580.  
  581. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  582.  
  583. gtk_layout_put(GTK_LAYOUT(layout), label, 10, 30);
  584. gtk_layout_put(GTK_LAYOUT(layout), entry, 200, 25);
  585. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 70);
  586. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 70);
  587.  
  588. gtk_container_add(GTK_CONTAINER(voteaza_melodie), layout);
  589.  
  590. g_object_set_data(G_OBJECT(continua), "parent", voteaza_melodie);
  591. g_object_set_data(G_OBJECT(continua), "entry", entry);
  592.  
  593. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), voteaza_melodie);
  594. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_voteaza_melodie), continua);
  595. gtk_widget_show_all(voteaza_melodie);
  596.  
  597. }
  598.  
  599. static void on_continue_adauga_melodie(GtkButton *button, GObject *context_object)
  600. {
  601. GtkWindow *parent = g_object_get_data(context_object, "parent");
  602. GtkEntry *entry_nume = g_object_get_data(context_object, "entry_nume");
  603. GtkEntry *entry_desc = g_object_get_data(context_object, "entry_desc");
  604. GtkEntry *entry_link = g_object_get_data(context_object, "entry_link");
  605. GtkEntry *entry_gen1 = g_object_get_data(context_object, "entry_gen1");
  606. GtkEntry *entry_gen2 = g_object_get_data(context_object, "entry_gen2");
  607. GtkEntry *entry_gen3 = g_object_get_data(context_object, "entry_gen3");
  608.  
  609. char *nume = gtk_entry_get_text(entry_nume);
  610. char *desc = gtk_entry_get_text(entry_desc);
  611. char *link = gtk_entry_get_text(entry_link);
  612. char *gen1 = gtk_entry_get_text(entry_gen1);
  613. char *gen2 = gtk_entry_get_text(entry_gen2);
  614. char *gen3 = gtk_entry_get_text(entry_gen3);
  615.  
  616. int ok = 1;
  617. if(strlen(nume) == 0 || strlen(desc) == 0 || strlen(link) == 0 || strlen(gen1) == 0)
  618. {
  619. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  620. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati toate campurile!");
  621. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  622. gtk_dialog_run(GTK_DIALOG(warning));
  623. gtk_widget_destroy(warning);
  624. ok = 0;
  625. }
  626.  
  627. if(ok == 1)
  628. {
  629. int size_comm = strlen("adauga_melodie");
  630.  
  631. if(write(sd, &size_comm, sizeof(int)) <= 0)
  632. {
  633. perror("Eroare la scrierea catre server");
  634. return errno;
  635. }
  636. if(write(sd, "adauga_melodie", size_comm) <= 0)
  637. {
  638. perror("Eroare la scrierea catre server");
  639. return errno;
  640. }
  641.  
  642. int size_nume = strlen(nume);
  643. if(write(sd, &size_nume, sizeof(int)) <= 0)
  644. {
  645. perror("Eroare la scrierea catre server");
  646. return errno;
  647. }
  648. if(write(sd, nume, size_nume) <= 0)
  649. {
  650. perror("Eroare la scrierea catre server");
  651. return errno;
  652. }
  653.  
  654. int size_desc = strlen(desc);
  655. if(write(sd, &size_desc, sizeof(int)) <= 0)
  656. {
  657. perror("Eroare la scrierea catre server");
  658. return errno;
  659. }
  660. if(write(sd, desc, size_desc) <= 0)
  661. {
  662. perror("Eroare la scrierea catre server");
  663. return errno;
  664. }
  665. int size_link = strlen(link);
  666. if(write(sd, &size_link, sizeof(int)) <= 0)
  667. {
  668. perror("Eroare la scrierea catre server");
  669. return errno;
  670. }
  671. if(write(sd, link, size_link) <= 0)
  672. {
  673. perror("Eroare la scrierea catre server");
  674. return errno;
  675. }
  676. int size_gen1 = strlen(gen1);
  677. if(write(sd, &size_gen1, sizeof(int)) <= 0)
  678. {
  679. perror("Eroare la scrierea catre server");
  680. return errno;
  681. }
  682. if(write(sd, gen1, size_gen1) <= 0)
  683. {
  684. perror("Eroare la scrierea catre server");
  685. return errno;
  686. }
  687.  
  688. int count = 0;
  689. if(strlen(gen2) > 0)
  690. count ++;
  691. if(strlen(gen3) > 0)
  692. count++;
  693.  
  694. if(write(sd, &count, sizeof(int)) <= 0)
  695. {
  696. perror("Eroare la scrierea catre server");
  697. return errno;
  698. }
  699. if(count == 1)
  700. {
  701. int size_gen2 = strlen(gen2);
  702. if(write(sd, &size_gen2, gen2) <= 0)
  703. {
  704. perror("Eroare la write catre server!");
  705. return errno;
  706. }
  707. if(write(sd, gen2, size_gen2) <= 0)
  708. {
  709. perror("Eroare la write catre server");
  710. return errno;
  711. }
  712. }
  713. if(count == 2)
  714. {
  715. int size_gen2 = strlen(gen2);
  716. if(write(sd, &size_gen2, sizeof(int)) <= 0)
  717. {
  718. perror("Eroare la write catre server");
  719. return errno;
  720. }
  721. if(write(sd, gen2, size_gen2) <= 0)
  722. {
  723. perror("Eroare la write catre server");
  724. return errno;
  725. }
  726. int size_gen3 = strlen(gen3);
  727. if(write(sd, &size_gen3, sizeof(int)) <= 0)
  728. {
  729. perror("Eroare la write catre server");
  730. return errno;
  731. }
  732. if(write(sd, gen3, size_gen3) <= 0)
  733. {
  734. perror("Eroare la write catre server");
  735. return errno;
  736. }
  737. }
  738.  
  739. int ok_gen = 0;
  740. if(read(sd, &ok_gen, sizeof(int)) <= 0)
  741. {
  742. perror("Eroare la read catre server!");
  743. return errno;
  744. }
  745.  
  746. if(ok_gen == 0)
  747. {
  748. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  749. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Genul introdus de tine nu exista!");
  750. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  751. gtk_dialog_run(GTK_DIALOG(warning));
  752. gtk_widget_destroy(warning);
  753. }
  754. else{
  755. int exists = 0;
  756. if(read(sd, &exists, sizeof(int)) <= 0)
  757. {
  758. perror("Eroare la read de la server");
  759. return errno;
  760. }
  761. if(exists == 1)
  762. {
  763. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  764. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodia exista deja in baza de date!");
  765. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  766. gtk_dialog_run(GTK_DIALOG(warning));
  767. gtk_widget_destroy(warning);
  768. }
  769. else{
  770. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  771. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodie adaugata cu succes!");
  772. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  773. gtk_dialog_run(GTK_DIALOG(warning));
  774. gtk_widget_destroy(warning);
  775. }
  776. }
  777. }
  778. }
  779.  
  780.  
  781.  
  782. static void on_adauga_melodie(GtkButton *button, gpointer menu)
  783. {
  784. GtkWindow *parent = menu;
  785. GtkWidget *adauga_mel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  786. gtk_window_set_title(GTK_WINDOW(adauga_mel), "Adauga o melodie");
  787. gtk_window_set_default_size(GTK_WINDOW(adauga_mel), 400, 350);
  788.  
  789. GtkWidget *label_nume, *entry_nume, *label_desc, *entry_desc, *label_link, *entry_link, *entry_gen1, *entry_gen2, *entry_gen3, *label_gen1, *label_gen2, *label_gen3;
  790. label_nume = gtk_label_new("Introdu numele:");
  791. entry_nume = gtk_entry_new();
  792. label_desc = gtk_label_new("Introdu decrierea:");
  793. entry_desc = gtk_entry_new();
  794. label_link = gtk_label_new("Introdu link-ul:");
  795. entry_link = gtk_entry_new();
  796. entry_gen1 = gtk_entry_new();
  797. entry_gen2 = gtk_entry_new();
  798. entry_gen3 = gtk_entry_new();
  799. label_gen1 = gtk_label_new("Genul 1 (obligatoriu) :");
  800. label_gen2 = gtk_label_new("Genul 2 (optional) :");
  801. label_gen3 = gtk_label_new("Genul 3 (optional) :");
  802. GtkWidget *continua, *renunta;
  803. continua = gtk_button_new_with_label("Continua");
  804. renunta = gtk_button_new_with_label("Renunta");
  805.  
  806. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  807.  
  808. gtk_layout_put(GTK_LAYOUT(layout), label_nume, 10, 30);
  809. gtk_layout_put(GTK_LAYOUT(layout), entry_nume , 180, 25);
  810. gtk_layout_put(GTK_LAYOUT(layout), label_desc, 10, 70);
  811. gtk_layout_put(GTK_LAYOUT(layout), entry_desc, 180, 65);
  812. gtk_layout_put(GTK_LAYOUT(layout), label_link, 10, 110);
  813. gtk_layout_put(GTK_LAYOUT(layout), entry_link, 180, 105);
  814. gtk_layout_put(GTK_LAYOUT(layout), label_gen1, 10, 150);
  815. gtk_layout_put(GTK_LAYOUT(layout), entry_gen1, 180, 145);
  816. gtk_layout_put(GTK_LAYOUT(layout), label_gen2, 10, 190);
  817. gtk_layout_put(GTK_LAYOUT(layout), entry_gen2, 180, 185);
  818. gtk_layout_put(GTK_LAYOUT(layout), label_gen3, 10, 230);
  819. gtk_layout_put(GTK_LAYOUT(layout), entry_gen3, 180, 225);
  820. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 270);
  821. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 270);
  822.  
  823. g_object_set_data(G_OBJECT(continua), "parent", adauga_mel);
  824. g_object_set_data(G_OBJECT(continua), "entry_nume", entry_nume);
  825. g_object_set_data(G_OBJECT(continua), "entry_desc", entry_desc);
  826. g_object_set_data(G_OBJECT(continua), "entry_link", entry_link);
  827. g_object_set_data(G_OBJECT(continua), "entry_gen1", entry_gen1);
  828. g_object_set_data(G_OBJECT(continua), "entry_gen2", entry_gen2);
  829. g_object_set_data(G_OBJECT(continua), "entry_gen3", entry_gen3);
  830.  
  831. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), adauga_mel);
  832. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continue_adauga_melodie), continua);
  833.  
  834. gtk_container_add(GTK_CONTAINER(adauga_mel), layout);
  835. gtk_widget_show_all(adauga_mel);
  836.  
  837. }
  838.  
  839. static void on_continua_adauga_gen(GtkButton *button, GObject *context_object)
  840. {
  841. GtkWindow *parent = g_object_get_data(context_object, "parent");
  842. GtkEntry *entry_nume = g_object_get_data(context_object, "entry");
  843.  
  844. int ok = 1;
  845. char *nume = gtk_entry_get_text(entry_nume);
  846. if(strlen(nume) == 0)
  847. {
  848. ok = 0;
  849. }
  850. if(ok == 1)
  851. {
  852. int size_comm = strlen("adauga_gen");
  853. if(write(sd, &size_comm, sizeof(int)) <= 0)
  854. {
  855. perror("Eroare la scriere catre server");
  856. return errno;
  857. }
  858. if(write(sd, "adauga_gen", size_comm) <= 0)
  859. {
  860. perror("Eroare la scriere catre server");
  861. return errno;
  862. }
  863.  
  864. int size_nume = strlen(nume);
  865. if(write(sd, &size_nume, sizeof(int)) <= 0)
  866. {
  867. perror("Eroare la scriere catre server");
  868. return errno;
  869. }
  870. if(write(sd, nume, size_nume) <= 0)
  871. {
  872. perror("Eroare la scrierea catre server");
  873. return errno;
  874. }
  875.  
  876. int exists = 0;
  877. if(read(sd, &exists, sizeof(int)) <= 0)
  878. {
  879. perror("Eroare la read de la server");
  880. return errno;
  881. }
  882.  
  883. if(exists == 1)
  884. {
  885. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  886. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Genul exista in baza de date!");
  887. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  888. gtk_dialog_run(GTK_DIALOG(warning));
  889. gtk_widget_destroy(warning);
  890. }
  891. else
  892. {
  893. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  894. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Gen adaugat cu succes!");
  895. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  896. gtk_dialog_run(GTK_DIALOG(warning));
  897. gtk_widget_destroy(warning);
  898. }
  899. }
  900. }
  901.  
  902. static void on_adauga_gen(GtkButton *button, gpointer _parent)
  903. {
  904. GtkWindow *parent = _parent;
  905. GtkWidget *adauga_gen, *label, *entry, *continua, *renunta;
  906.  
  907. adauga_gen = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  908. gtk_window_set_title(GTK_WINDOW(adauga_gen), "Adauga un gen muzical");
  909. gtk_window_set_default_size(GTK_WINDOW(adauga_gen), 400, 200);
  910.  
  911. label = gtk_label_new("Introdu noul gen aici: ");
  912. entry = gtk_entry_new();
  913. continua = gtk_button_new_with_label("Continua");
  914. renunta = gtk_button_new_with_label("Renunta");
  915.  
  916. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  917. gtk_layout_put(GTK_LAYOUT(layout), label, 10, 30);
  918. gtk_layout_put(GTK_LAYOUT(layout), entry, 180, 25);
  919. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 70);
  920. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 70);
  921.  
  922. gtk_container_add(GTK_CONTAINER(adauga_gen), layout);
  923.  
  924. g_object_set_data(G_OBJECT(continua), "parent", adauga_gen);
  925. g_object_set_data(G_OBJECT(continua), "entry", entry);
  926.  
  927. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), adauga_gen);
  928. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_adauga_gen), continua);
  929.  
  930. gtk_widget_show_all(adauga_gen);
  931. }
  932.  
  933. static void on_back_admin(GtkButton *button, gpointer parent)
  934. {
  935. GtkWindow *_parent = parent;
  936. int size_comm = strlen("back");
  937.  
  938. if(write(sd, &size_comm, sizeof(int)) <= 0)
  939. {
  940. perror("Eroare la write catre server");
  941. return errno;
  942. }
  943.  
  944. if(write(sd, "back", size_comm) <= 0)
  945. {
  946. perror("Eroare la write catre server");
  947. return errno;
  948. }
  949. gtk_widget_destroy(_parent);
  950. }
  951.  
  952. static void on_respinge_admin(GtkButton *button, GObject *context_object)
  953. {
  954. GtkWindow *parent = g_object_get_data(context_object, "parent");
  955. GtkEntry *entry_nume = g_object_get_data(context_object, "entry");
  956.  
  957. char *nume = gtk_entry_get_text(entry_nume);
  958. int ok = 1;
  959. if(strlen(nume) == 0)
  960. {
  961. ok = 0;
  962. }
  963. if(ok == 1)
  964. {
  965. int size_comm = strlen("respinge_admin");
  966. if(write(sd, &size_comm, sizeof(int)) <= 0)
  967. {
  968. perror("Eroare la scriere catre server");
  969. return errno;
  970. }
  971. if(write(sd, "respinge_admin", size_comm) <= 0)
  972. {
  973. perror("Eroare la scrierea catre server");
  974. return errno;
  975. }
  976.  
  977. int size_nume = strlen(nume);
  978. if(write(sd, &size_nume, sizeof(int)) <= 0)
  979. {
  980. perror("Eroare la scrierea catre server");
  981. return errno;
  982. }
  983.  
  984. if(write(sd, nume, size_nume) <= 0)
  985. {
  986. perror("Erore la scriere catre server");
  987. return errno;
  988. }
  989.  
  990. int exists = 0;
  991. if(read(sd, &exists, sizeof(int)) <= 0)
  992. {
  993. perror("Eroare la citire de la server");
  994. return errno;
  995. }
  996.  
  997. if(exists == 0)
  998. {
  999. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1000. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Utilizatorul nu a fost gasit in baza de date!");
  1001. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1002. gtk_dialog_run(GTK_DIALOG(warning));
  1003. gtk_widget_destroy(warning);
  1004. }
  1005. else
  1006. {
  1007. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1008. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Admin respins cu succes!");
  1009. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1010. gtk_dialog_run(GTK_DIALOG(warning));
  1011. gtk_widget_destroy(warning);
  1012. }
  1013. }
  1014.  
  1015. }
  1016.  
  1017. static void accepta_accepta_admin(GtkButton *button, GObject *context_object)
  1018. {
  1019. GtkWindow *parent = g_object_get_data(context_object, "parent");
  1020. GtkEntry *entry_nume = g_object_get_data(context_object, "entry");
  1021. int ok = 1;
  1022.  
  1023. char *nume = gtk_entry_get_text(entry_nume);
  1024. if(strlen(nume) == 0)
  1025. ok = 0;
  1026.  
  1027. if(ok == 1)
  1028. {
  1029. int size_comm = strlen("accepta_admin");
  1030. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1031. {
  1032. perror("Eroare la write catre server");
  1033. return errno;
  1034. }
  1035.  
  1036. if(write(sd, "accepta_admin", size_comm) <= 0)
  1037. {
  1038. perror("Eroare la write catre server");
  1039. return errno;
  1040. }
  1041.  
  1042. int size_name = strlen(nume);
  1043. if(write(sd, &size_name, sizeof(int)) <= 0)
  1044. {
  1045. perror("Eroare la write catre server");
  1046. return errno;
  1047. }
  1048.  
  1049. if(write(sd, nume, size_name) <= 0)
  1050. {
  1051. perror("Eroare la write catre server");
  1052. return errno;
  1053. }
  1054.  
  1055. int exists = 0;
  1056.  
  1057. if(read(sd, &exists, sizeof(int)) <= 0)
  1058. {
  1059. perror("Eroare la read de la server");
  1060. return errno;
  1061. }
  1062. if(exists == 0)
  1063. {
  1064. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1065. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Utilizatorul nu a fost gasit in baza de date!");
  1066. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1067. gtk_dialog_run(GTK_DIALOG(warning));
  1068. gtk_widget_destroy(warning);
  1069. }else{
  1070. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1071. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Admin acceptat cu succes!");
  1072. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1073. gtk_dialog_run(GTK_DIALOG(warning));
  1074. gtk_widget_destroy(warning);
  1075. }
  1076.  
  1077. }
  1078. }
  1079.  
  1080. static void on_continua_sterge_melodie(GtkButton *button, GObject *context_object)
  1081. {
  1082. GtkWindow *parent = g_object_get_data(context_object, "parent");
  1083. GtkEntry *nume = g_object_get_data(context_object, "entry");
  1084. int ok = 1;
  1085. char *titlu_melodie = gtk_entry_get_text(nume);
  1086. if(strlen(titlu_melodie) == 0)
  1087. {
  1088. ok = 0;
  1089. }
  1090. if(ok == 1){
  1091. int size_comm = strlen("sterge_melodie");
  1092. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1093. {
  1094. perror("Eroare la scrierea catre server!");
  1095. return errno;
  1096. }
  1097.  
  1098. if(write(sd, "sterge_melodie", size_comm) <= 0)
  1099. {
  1100. perror("Eroare la scrierea catre server!");
  1101. return errno;
  1102. }
  1103. int size_titlu = strlen(titlu_melodie);
  1104. if(write(sd, &size_titlu, sizeof(int)) <= 0)
  1105. {
  1106. perror("Eroare la scrierea catre server");
  1107. return errno;
  1108. }
  1109. if(write(sd, titlu_melodie, size_titlu) <= 0)
  1110. {
  1111. perror("Eroare la scrierea catre server");
  1112. return errno;
  1113. }
  1114.  
  1115. int exists = 0;
  1116. if(read(sd, &exists, sizeof(int)) <= 0)
  1117. {
  1118. perror("Eroare la read de la server");
  1119. return errno;
  1120. }
  1121. if(exists == 0)
  1122. {
  1123. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1124. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodia nu exista in baza de date!");
  1125. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1126. gtk_dialog_run(GTK_DIALOG(warning));
  1127. gtk_widget_destroy(warning);
  1128. }
  1129. else{
  1130. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1131. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Melodie stearsa cu succes!");
  1132. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1133. gtk_dialog_run(GTK_DIALOG(warning));
  1134. gtk_widget_destroy(warning);
  1135. }
  1136.  
  1137. }
  1138. }
  1139.  
  1140. static void on_sterge_melodie(GtkButton *button, gpointer menu)
  1141. {
  1142. GtkWindow *parent = menu;
  1143. GtkWidget *sterge_melodie = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1144. gtk_window_set_title(GTK_WINDOW(sterge_melodie), "Blocheaza un utilizator!");
  1145. gtk_window_set_default_size(GTK_WINDOW(sterge_melodie), 400, 200);
  1146.  
  1147. GtkWidget *entry_nume, *continua, *renunta, *entry_label;
  1148. entry_nume = gtk_entry_new();
  1149. entry_label = gtk_label_new("Introdu numele melodiei :");
  1150. continua = gtk_button_new_with_label("Continua");
  1151. renunta = gtk_button_new_with_label("Renunta");
  1152.  
  1153. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  1154. gtk_layout_put(GTK_LAYOUT(layout), entry_label, 10, 30);
  1155. gtk_layout_put(GTK_LAYOUT(layout), entry_nume, 180, 25);
  1156. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 70);
  1157. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 70);
  1158.  
  1159. gtk_container_add(GTK_CONTAINER(sterge_melodie), layout);
  1160.  
  1161. g_object_set_data(G_OBJECT(continua), "parent", sterge_melodie);
  1162. g_object_set_data(G_OBJECT(continua), "entry", entry_nume);
  1163.  
  1164. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), sterge_melodie);
  1165. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continua_sterge_melodie), continua);
  1166.  
  1167. gtk_widget_show_all(sterge_melodie);
  1168.  
  1169. }
  1170.  
  1171. static void on_accepta_admin(GtkButton *button, gpointer menu)
  1172. {
  1173. GtkWindow *parent = menu;
  1174. int size_comm = strlen("accepta_admin");
  1175. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1176. {
  1177. perror("Eroare la scrierea catre server");
  1178. return errno;
  1179. }
  1180.  
  1181. if(write(sd, "accepta_admin", size_comm) <= 0)
  1182. {
  1183. perror("Eroare la scrierea catre server");
  1184. return errno;
  1185. }
  1186.  
  1187. int k = 0;
  1188. if(read(sd, &k, sizeof(int)) <= 0)
  1189. {
  1190. perror("Eroare la read() de la server");
  1191. return errno;
  1192. }
  1193.  
  1194. char nume[100][100];
  1195. bzero(nume, sizeof(nume));
  1196. for(int i = 0; i < k; i++)
  1197. {
  1198. if(read(sd, nume[i], 100) <= 0)
  1199. {
  1200. perror("eroare la read() de la server");
  1201. return errno;
  1202. }
  1203. }
  1204.  
  1205. GtkWidget *entry, *accepta_admin, *label, *back, *accepta, *respinge;
  1206. accepta_admin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1207. gtk_window_set_title(GTK_WINDOW(accepta_admin), "Adauga un admin!");
  1208. gtk_window_set_default_size(GTK_WINDOW(accepta_admin), 400, 200);
  1209.  
  1210. char text[200];
  1211. bzero(text, 200);
  1212. strcat(text, "Cereri :");
  1213. for(int i = 0; i < k; i++)
  1214. {
  1215. if(i != 0)
  1216. strcat(text, ",");
  1217. strcat(text, nume[i]);
  1218. }
  1219.  
  1220. label = gtk_label_new(text);
  1221.  
  1222. accepta = gtk_button_new_with_label("Accepta");
  1223. respinge = gtk_button_new_with_label("Respinge");
  1224. back = gtk_button_new_with_label("Back");
  1225. entry = gtk_entry_new();
  1226. GtkWidget *entry_label = gtk_label_new("Introdu numele :");
  1227.  
  1228.  
  1229. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  1230. gtk_layout_put(GTK_LAYOUT(layout), label, 10, 30);
  1231. gtk_layout_put(GTK_LAYOUT(layout), entry_label, 10, 70);
  1232. gtk_layout_put(GTK_LAYOUT(layout), entry, 180, 65);
  1233. gtk_layout_put(GTK_LAYOUT(layout), respinge, 10, 110);
  1234. gtk_layout_put(GTK_LAYOUT(layout), accepta, 300, 110);
  1235. gtk_layout_put(GTK_LAYOUT(layout), back, 10, 160);
  1236.  
  1237. gtk_container_add(GTK_CONTAINER(accepta_admin), layout);
  1238. g_object_set_data(G_OBJECT(accepta), "entry", entry);
  1239. g_object_set_data(G_OBJECT(accepta), "parent", accepta_admin);
  1240.  
  1241. g_object_set_data(G_OBJECT(respinge), "entry", entry);
  1242. g_object_set_data(G_OBJECT(respinge), "parent", accepta_admin);
  1243.  
  1244. g_signal_connect(GTK_BUTTON(accepta), "clicked", G_CALLBACK(accepta_accepta_admin), accepta);
  1245. g_signal_connect(GTK_BUTTON(respinge), "clicked", G_CALLBACK(on_respinge_admin), respinge);
  1246. g_signal_connect(GTK_BUTTON(back), "clicked", G_CALLBACK(on_back_admin), accepta_admin);
  1247.  
  1248. gtk_widget_show_all(accepta_admin);
  1249.  
  1250. }
  1251.  
  1252. static void on_renunta(GtkButton *button, gpointer destroy)
  1253. {
  1254. GtkWindow *_destroy = destroy;
  1255. gtk_widget_destroy(GTK_WIDGET(_destroy));
  1256. }
  1257.  
  1258. static void on_continue_block_user(GtkButton *button, GObject *context_object)
  1259. {
  1260. GtkEntry *name = g_object_get_data(context_object, "nume");
  1261. GtkEntry *parent = g_object_get_data(context_object, "parent");
  1262.  
  1263. char *nume = gtk_entry_get_text(name);
  1264. int ok = 1;
  1265. if(strlen(nume) == 0)
  1266. {
  1267. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1268. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati campul!");
  1269. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1270. gtk_dialog_run(GTK_DIALOG(warning));
  1271. gtk_widget_destroy(warning);
  1272. ok = 0;
  1273. }
  1274. //trimitem comanda la server
  1275. if(ok == 1){
  1276. int size_comm = strlen("blocare_user");
  1277. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1278. {
  1279. perror("Eroare la scrierea catre server!");
  1280. return errno;
  1281. }
  1282. if(write(sd, "blocare_user", size_comm) <= 0)
  1283. {
  1284. perror("Eroare la scrierea catre server!");
  1285. return errno;
  1286. }
  1287.  
  1288. //trimitem numele la server
  1289. int size_nume = strlen(nume);
  1290. if(write(sd, &size_nume, sizeof(int)) <= 0)
  1291. {
  1292. perror("Eroare la scrierea catre server!");
  1293. return errno;
  1294. }
  1295. if(write(sd, nume, size_nume) <= 0)
  1296. {
  1297. perror("Eroare la scrierea catre server!");
  1298. return errno;
  1299. }
  1300.  
  1301. int exists = 0;
  1302. if(read(sd, &exists, sizeof(int)) <= 0)
  1303. {
  1304. perror("Eroare la citirea de la server");
  1305. return errno;
  1306. }
  1307. if(exists == 0)
  1308. {
  1309. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1310. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Utilizatorul nu exista in baza de date");
  1311. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1312. gtk_dialog_run(GTK_DIALOG(warning));
  1313. gtk_widget_destroy(warning);
  1314. }
  1315. if(exists == 1)
  1316. {
  1317. int is_blocked = 0;
  1318. if(read(sd, &is_blocked, sizeof(int)) <= 0)
  1319. {
  1320. perror("Eroare la citirea de la server");
  1321. return errno;
  1322. }
  1323. if(is_blocked == 1)
  1324. {
  1325. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1326. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "User-ul este deja blocat!");
  1327. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1328. gtk_dialog_run(GTK_DIALOG(warning));
  1329. gtk_widget_destroy(warning);
  1330. }
  1331. else{
  1332. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1333. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Utilizator blocat!");
  1334. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1335. gtk_dialog_run(GTK_DIALOG(warning));
  1336. gtk_widget_destroy(warning);
  1337. gtk_widget_destroy(GTK_WIDGET(parent));
  1338. }
  1339. }
  1340.  
  1341. }
  1342. }
  1343. static void on_blocheaza_user(GtkButton *button, gpointer menu_admin)
  1344. {
  1345. GtkWindow *parent = menu_admin;
  1346. GtkWidget *block_user = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1347. gtk_window_set_title(GTK_WINDOW(block_user), "Blocheaza un utilizator!");
  1348. gtk_window_set_default_size(GTK_WINDOW(block_user), 400, 200);
  1349.  
  1350. GtkWidget *entry_nume, *entry_label;
  1351. entry_label = gtk_label_new("Introdu numele :");
  1352. entry_nume = gtk_entry_new();
  1353.  
  1354. GtkWidget *renunta, *continua;
  1355. renunta = gtk_button_new_with_label("Renunta");
  1356. continua = gtk_button_new_with_label("Continua");
  1357.  
  1358. GtkLayout *layout = gtk_layout_new(NULL, NULL);
  1359. gtk_layout_put(GTK_LAYOUT(layout), entry_label, 10, 30);
  1360. gtk_layout_put(GTK_LAYOUT(layout), entry_nume, 180, 25);
  1361. gtk_layout_put(GTK_LAYOUT(layout), renunta, 10, 70);
  1362. gtk_layout_put(GTK_LAYOUT(layout), continua, 300, 70);
  1363.  
  1364. gtk_container_add(GTK_CONTAINER(block_user), layout);
  1365.  
  1366. g_object_set_data(G_OBJECT(continua), "nume", entry_nume);
  1367. g_object_set_data(G_OBJECT(continua), "parent", block_user);
  1368.  
  1369. g_signal_connect(GTK_BUTTON(renunta), "clicked", G_CALLBACK(on_renunta), block_user);
  1370. g_signal_connect(GTK_BUTTON(continua), "clicked", G_CALLBACK(on_continue_block_user), continua);
  1371.  
  1372. gtk_widget_show_all(block_user);
  1373. }
  1374.  
  1375. static void back_to_menu(GtkButton *button, gpointer parent)
  1376. {
  1377. GtkWindow *_parent = parent;
  1378. gtk_widget_destroy(GTK_WIDGET(_parent));
  1379.  
  1380. GtkWidget *menu;
  1381. GtkWidget *main_menu = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1382. gtk_window_set_default_size(GTK_WINDOW(main_menu), 400, 400);
  1383. gtk_window_set_title(GTK_WINDOW(main_menu), "TopMusic");
  1384.  
  1385. GtkWidget *label, *inreg_admin, *inreg_user, *logare_admin, *logare_user, *quit;
  1386.  
  1387. label = gtk_label_new("Alege una din optiunile de mai jos:");
  1388. inreg_admin = gtk_button_new_with_label("Inregistrare ca admin");
  1389. inreg_user = gtk_button_new_with_label("Inregistrare");
  1390. logare_admin = gtk_button_new_with_label("Logare ca admin");
  1391. logare_user = gtk_button_new_with_label("Logare");
  1392. quit = gtk_button_new_with_label("Quit");
  1393.  
  1394. GtkWidget *box;
  1395. box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  1396.  
  1397. gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 10);
  1398. gtk_box_pack_start(GTK_BOX(box), inreg_admin, TRUE, TRUE, 10);
  1399. gtk_box_pack_start(GTK_BOX(box), logare_admin, TRUE, TRUE, 10);
  1400. gtk_box_pack_start(GTK_BOX(box), inreg_user, TRUE, TRUE, 10);
  1401. gtk_box_pack_start(GTK_BOX(box), logare_user, TRUE, TRUE, 10);
  1402. gtk_box_pack_start(GTK_BOX(box), quit, TRUE, TRUE, 10);
  1403.  
  1404.  
  1405. g_signal_connect(GTK_BUTTON(inreg_admin), "clicked", G_CALLBACK(inregistrare_admin), main_menu);
  1406. g_signal_connect(GTK_BUTTON(logare_admin), "clicked", G_CALLBACK(login_admin), main_menu);
  1407. g_signal_connect(GTK_BUTTON(inreg_user), "clicked", G_CALLBACK(inregistrare_utilizator), main_menu);
  1408. g_signal_connect(GTK_BUTTON(logare_user), "clicked", G_CALLBACK(logare_utilizator), main_menu);
  1409. g_signal_connect(GTK_BUTTON(quit), "clicked", G_CALLBACK(quit_out), main_menu);
  1410.  
  1411. gtk_container_add(GTK_CONTAINER(main_menu), box);
  1412.  
  1413. gtk_widget_show_all(main_menu);
  1414. }
  1415.  
  1416. static void on_inregistrare_user(GtkButton *button, GObject *context_object)
  1417. {
  1418. GtkEntry *name_entry = g_object_get_data(context_object, "nume");
  1419. GtkEntry *pass_entry = g_object_get_data(context_object, "parola");
  1420. GtkEntry *re_pass = g_object_get_data(context_object, "re_pass");
  1421. GtkEntry *parent = g_object_get_data(context_object, "parent");
  1422.  
  1423. char *nume, *parola, *re_parola;
  1424. nume = gtk_entry_get_text(name_entry);
  1425. parola = gtk_entry_get_text(pass_entry);
  1426. re_parola = gtk_entry_get_text(re_pass);
  1427.  
  1428. int ok = 1;
  1429.  
  1430. if(strlen(nume) == 0 || strlen(parola) == 0 || strlen(re_parola) == 0)
  1431. {
  1432. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1433. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati toate campurile");
  1434. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1435. gtk_dialog_run(GTK_DIALOG(warning));
  1436. gtk_widget_destroy(warning);
  1437. ok = 0;
  1438. }
  1439.  
  1440. if(strcmp(parola, re_parola) != 0)
  1441. {
  1442. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1443. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Parolele nu se potrivesc");
  1444. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1445. gtk_dialog_run(GTK_DIALOG(warning));
  1446. gtk_widget_destroy(warning);
  1447. ok = 0;
  1448. }
  1449.  
  1450. //trimitem datele catre server
  1451. if(ok == 1){
  1452. int size_comm = strlen("inregistrare_user");
  1453.  
  1454. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1455. {
  1456. perror("Eroare la scriere catre server");
  1457. return errno;
  1458. }
  1459.  
  1460. if(write(sd, "inregistrare_user", size_comm) <= 0)
  1461. {
  1462. perror("Eroare la scrierea catre server");
  1463. return errno;
  1464. }
  1465.  
  1466. int size_nume = strlen(nume);
  1467. if(write(sd, &size_nume, sizeof(int)) <= 0)
  1468. {
  1469. perror("Eroare la scriere catre server");
  1470. return errno;
  1471. }
  1472.  
  1473. if(write(sd, nume, size_nume) <= 0)
  1474. {
  1475. perror("Eroare la scrierea catre server");
  1476. return errno;
  1477. }
  1478.  
  1479. int size_pass = strlen(parola);
  1480. if(write(sd, &size_pass, sizeof(int)) <= 0)
  1481. {
  1482. perror("Eroare la scrierea catre server");
  1483. return errno;
  1484. }
  1485. if(write(sd, parola, size_pass) <= 0)
  1486. {
  1487. perror("Eroare la scrierea catre server");
  1488. return errno;
  1489. }
  1490.  
  1491. int exists = 0;
  1492.  
  1493. if(read(sd, &exists, sizeof(int)) <= 0)
  1494. {
  1495. perror("Eroare la citirea de la server");
  1496. return errno;
  1497. }
  1498.  
  1499. if(exists == 1)
  1500. {
  1501. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1502. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "User-name folosit! Te rugam alege altul!");
  1503. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1504. gtk_dialog_run(GTK_DIALOG(warning));
  1505. gtk_widget_destroy(warning);
  1506. }
  1507. else
  1508. g_print("Succes!");
  1509.  
  1510. }
  1511. }
  1512.  
  1513. static void on_logare_user(GtkButton *button, GObject *context_object)
  1514. {
  1515. GtkEntry *name_entry = g_object_get_data(context_object, "nume");
  1516. GtkEntry *pass_entry = g_object_get_data(context_object, "parola");
  1517. GtkWindow *parent = g_object_get_data(context_object, "parent");
  1518.  
  1519. char *nume, *pass;
  1520. nume = gtk_entry_get_text(name_entry);
  1521. pass = gtk_entry_get_text(pass_entry);
  1522. int okk = 1;
  1523. if(strlen(nume) == 0 || strlen(pass) == 0)
  1524. {
  1525. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1526. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati toate campurile");
  1527. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1528. gtk_dialog_run(GTK_DIALOG(warning));
  1529. gtk_widget_destroy(warning);
  1530. okk = 0;
  1531. }
  1532.  
  1533. //gooo
  1534. if(okk == 1){
  1535. int size_comm = strlen("logare_user");
  1536. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1537. {
  1538. perror("Eroare la scriere catre server!");
  1539. return errno;
  1540. gtk_destroy_widget(GTK_WIDGET(parent));
  1541. }
  1542.  
  1543. if(write(sd, "logare_user", strlen("logare_user")) <= 0)
  1544. {
  1545. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1546. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Eroare la scriere! Aplicatia se va inchide!");
  1547. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1548. gtk_dialog_run(GTK_DIALOG(warning));
  1549. gtk_widget_destroy(warning);
  1550. gtk_widget_destroy(GTK_WIDGET(parent));
  1551. }
  1552.  
  1553. //trimite size_nume
  1554. int size_nume = strlen(nume);
  1555. if(write(sd, &size_nume, sizeof(int)) <= 0)
  1556. {
  1557. perror("Eroare la scriere catre server");
  1558. return errno;
  1559. gtk_widget_destroy(GTK_WIDGET(parent));
  1560. }
  1561.  
  1562. //trimitem numele
  1563.  
  1564. if(write(sd, nume, strlen(nume)) <= 0)
  1565. {
  1566. perror("Eroare la scriere catre server");
  1567. return errno;
  1568. gtk_widget_destroy(GTK_WIDGET(parent));
  1569. }
  1570.  
  1571. //trimitem size_pass
  1572. int size_pass = strlen(pass);
  1573. if(write(sd, &size_pass, sizeof(int)) <= 0)
  1574. {
  1575. perror("Eroare la scrierea catre server");
  1576. return errno;
  1577. gtk_widget_destroy(GTK_WIDGET(parent));
  1578. }
  1579. //trimitem parola
  1580.  
  1581. if(write(sd, pass, strlen(pass)) <= 0)
  1582. {
  1583. perror("Eroare la scrierea catre server");
  1584. return errno;
  1585. gtk_widget_destroy(GTK_WIDGET(parent));
  1586. }
  1587.  
  1588. int ok;
  1589. printf("socket- ul %d \n", sd);
  1590. //asteptam raspunsul de la server
  1591. if(read(sd, &ok, sizeof(int)) <= 0)
  1592. {
  1593. perror("Eroare la citirea de la server --- raspuns");
  1594. return errno;
  1595. gtk_widget_destroy(GTK_WIDGET(parent));
  1596. }
  1597.  
  1598. if(ok == 0)
  1599. {
  1600. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1601. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Userul/parola nu se potrivesc!");
  1602. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1603. gtk_dialog_run(GTK_DIALOG(warning));
  1604. gtk_widget_destroy(warning);
  1605. }
  1606.  
  1607.  
  1608. else if(ok == 1)
  1609. {
  1610. g_print("Felicitari te-ai logat cu succes! ");
  1611. gtk_widget_destroy(GTK_WIDGET(parent));
  1612.  
  1613. GtkWidget *meniu_user = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1614. g_signal_connect(meniu_user, "delete_event", G_CALLBACK(quit_meniu), meniu_user);
  1615. gtk_window_set_default_size(GTK_WINDOW(meniu_user), 400, 400);
  1616. gtk_window_set_title(GTK_WINDOW(meniu_user), "TopMusic");
  1617.  
  1618. GtkWidget *cauta_melodie, *adauga_melodie, *voteaza_melodie, *vezi_topul;
  1619. GtkWidget *adauga_un_comentariu, *vezi_top_pe_genuri, *quit;
  1620. adauga_melodie = gtk_button_new_with_label("Adauga o melodie");
  1621. cauta_melodie = gtk_button_new_with_label("Cauta o melodie");
  1622. voteaza_melodie = gtk_button_new_with_label("Voteaza o melodie");
  1623. vezi_topul = gtk_button_new_with_label("Vezi topul general");
  1624. adauga_un_comentariu = gtk_button_new_with_label("Adauga un comentariu");
  1625. vezi_top_pe_genuri = gtk_button_new_with_label("Vezi topul pe genuri");
  1626. quit = gtk_button_new_with_label("Quit");
  1627.  
  1628. GtkWidget *label = gtk_label_new("Alege una din urmatoarele optiuni:");
  1629.  
  1630. GtkWidget *box;
  1631. box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  1632.  
  1633. gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5);
  1634. gtk_box_pack_start(GTK_BOX(box), adauga_melodie, TRUE, TRUE, 5);
  1635. gtk_box_pack_start(GTK_BOX(box), cauta_melodie, TRUE, TRUE, 5);
  1636. gtk_box_pack_start(GTK_BOX(box), voteaza_melodie, TRUE, TRUE, 5);
  1637. gtk_box_pack_start(GTK_BOX(box), vezi_topul, TRUE, TRUE, 5);
  1638. gtk_box_pack_start(GTK_BOX(box), adauga_un_comentariu, TRUE, TRUE, 5);
  1639. gtk_box_pack_start(GTK_BOX(box), vezi_top_pe_genuri, TRUE, TRUE, 5);
  1640. gtk_box_pack_start(GTK_BOX(box), quit, TRUE, TRUE, 5);
  1641.  
  1642. g_signal_connect(GTK_BUTTON(adauga_un_comentariu), "clicked", G_CALLBACK(on_adauga_comm), meniu_user);
  1643. g_signal_connect(GTK_BUTTON(quit), "clicked", G_CALLBACK(quit_out), meniu_user);
  1644. g_signal_connect(GTK_BUTTON(vezi_topul), "clicked", G_CALLBACK(top_general), meniu_user);
  1645. g_signal_connect(GTK_BUTTON(adauga_melodie), "clicked", G_CALLBACK(on_adauga_melodie), meniu_user);
  1646. g_signal_connect(GTK_BUTTON(voteaza_melodie), "clicked", G_CALLBACK(on_voteaza_melodie), meniu_user);
  1647. g_signal_connect(GTK_BUTTON(cauta_melodie), "clicked", G_CALLBACK(on_cauta_melodie), meniu_user);
  1648. g_signal_connect(GTK_BUTTON(vezi_top_pe_genuri), "clicked", G_CALLBACK(top_pe_genuri), meniu_user);
  1649. gtk_container_add(GTK_CONTAINER(meniu_user), box);
  1650.  
  1651. gtk_widget_show_all(meniu_user);
  1652.  
  1653. }
  1654. }
  1655. }
  1656.  
  1657. static void on_submit_inregistrare_admin(GtkButton *button, GObject *context_object)
  1658. {
  1659. GtkEntry *name_entry = g_object_get_data(context_object, "user");
  1660. GtkEntry *pass_entry = g_object_get_data(context_object, "pass");
  1661. GtkEntry *re_pass = g_object_get_data(context_object, "re_pass");
  1662. GtkEntry *mail = g_object_get_data(context_object, "mail");
  1663. GtkWindow *parent = g_object_get_data(context_object, "parent");
  1664.  
  1665. char *e_mail, *nume, *pass, *pass_re;
  1666. nume = gtk_entry_get_text(name_entry);
  1667. pass = gtk_entry_get_text(pass_entry);
  1668. pass_re = gtk_entry_get_text(re_pass);
  1669. e_mail = gtk_entry_get_text(mail);
  1670. g_print("%s", e_mail);
  1671. int ok = 1;
  1672.  
  1673. if(strlen(nume) == 0 || strlen(pass) == 0 || strlen(pass_re) == 0 || strlen(e_mail) == 0)
  1674. {
  1675. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1676. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati toate campurile");
  1677. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1678. gtk_dialog_run(GTK_DIALOG(warning));
  1679. gtk_widget_destroy(warning);
  1680. ok = 0;
  1681. }
  1682.  
  1683. if(strcmp(pass, pass_re) != 0)
  1684. {
  1685. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1686. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Parolele nu se potrivesc!");
  1687. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1688. gtk_dialog_run(GTK_DIALOG(warning));
  1689. gtk_widget_destroy(warning);
  1690. ok = 0;
  1691. }
  1692.  
  1693. // start
  1694. if(ok == 1){
  1695. int size_comanda = strlen("inregistrare_admin");
  1696. //trimitem size_comanda
  1697.  
  1698. if(write(sd, &size_comanda, sizeof(int)) <= 0)
  1699. {
  1700. perror("Eroare la scrierea in socket!");
  1701. return errno;
  1702. }
  1703.  
  1704. if(write(sd, "inregistrare_admin", strlen("inregistrare_admin")) <= 0)
  1705. {
  1706. perror("Eroare la scriere! \n");
  1707. return errno;
  1708. }
  1709.  
  1710. int size_nume = strlen(nume);
  1711.  
  1712. if(write(sd, &size_nume, sizeof(int)) <= 0)
  1713. {
  1714. perror("Eroare la scrierea in socket!");
  1715. return errno;
  1716. }
  1717.  
  1718. if(write(sd, nume, strlen(nume)) <= 0)
  1719. {
  1720. perror("Eroare la scrierea in socket!");
  1721. return errno;
  1722. }
  1723.  
  1724. int size_pass = strlen(pass);
  1725. if(write(sd, &size_pass, sizeof(int)) <= 0)
  1726. {
  1727. perror("Eroare la scrierea in socket!");
  1728. return errno;
  1729. }
  1730. if(write(sd, pass, size_pass) <= 0)
  1731. {
  1732. perror("Eroare la scrierea in socket!");
  1733. return errno;
  1734. }
  1735.  
  1736. int size_mail = strlen(e_mail);
  1737. if(write(sd, &size_mail, sizeof(int)) <= 0)
  1738. {
  1739. perror("Eroare la scrierea in socket!");
  1740. return errno;
  1741. }
  1742. if(write(sd, e_mail, size_mail) <= 0)
  1743. {
  1744. perror("Eroare la scrierea in socket!");
  1745. return errno;
  1746. }
  1747.  
  1748. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1749. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Cererea ta va fi analizata de catre echipa noastra. Vei primi un e-mail in cel mai scurt timp!");
  1750. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1751. gtk_dialog_run(GTK_DIALOG(warning));
  1752. gtk_widget_destroy(warning);
  1753. close(sd);
  1754. gtk_widget_destroy(GTK_WIDGET(parent));
  1755. }
  1756. }
  1757.  
  1758. static void on_log_admin(GtkButton *button, GObject *context_object)
  1759. {
  1760. GtkEntry *name = g_object_get_data(context_object, "user");
  1761. GtkEntry *pass = g_object_get_data(context_object, "pass");
  1762. GtkWindow *parent = g_object_get_data(context_object, "parent");
  1763.  
  1764. char *nume, *parola;
  1765. nume = gtk_entry_get_text(name);
  1766. parola = gtk_entry_get_text(pass);
  1767.  
  1768. int ok = 1;
  1769. if(strlen(nume) == 0 || strlen(parola) == 0)
  1770. {
  1771. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1772. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Completati toate campurile");
  1773. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1774. gtk_dialog_run(GTK_DIALOG(warning));
  1775. gtk_widget_destroy(warning);
  1776. ok = 0;
  1777. }
  1778.  
  1779. //trimitem datele la server
  1780. if(ok == 1)
  1781. {
  1782. int size_comm = strlen("logare_admin");
  1783.  
  1784. if(write(sd, &size_comm, sizeof(int)) <= 0)
  1785. {
  1786. perror("Eroare la scrierea catre server");
  1787. return errno;
  1788. }
  1789.  
  1790. if(write(sd, "logare_admin", size_comm) <= 0)
  1791. {
  1792. perror("Eroare la scrierea catre server");
  1793. return errno;
  1794. }
  1795.  
  1796. int size_nume = strlen(nume);
  1797. if(write(sd, &size_nume, sizeof(int)) <= 0)
  1798. {
  1799. perror("Eroare la scrierea catre server");
  1800. return errno;
  1801. }
  1802. if(write(sd, nume, size_nume) <= 0)
  1803. {
  1804. perror("Eroare la scrierea catre server");
  1805. return errno;
  1806. }
  1807.  
  1808. int size_pass = strlen(parola);
  1809. if(write(sd, &size_pass, sizeof(int)) <= 0)
  1810. {
  1811. perror("Eroare la scrierea catre server");
  1812. return errno;
  1813. }
  1814.  
  1815. if(write(sd, parola, size_pass) <= 0)
  1816. {
  1817. perror("Eroare la scrierea catre server");
  1818. return errno;
  1819. }
  1820.  
  1821. int accept;
  1822. //asteptam raspunsul de la server
  1823. if(read(sd, &accept, sizeof(int)) <= 0)
  1824. {
  1825. perror("Eroare la citirea de la server --- raspuns");
  1826. return errno;
  1827. gtk_widget_destroy(GTK_WIDGET(parent));
  1828. }
  1829.  
  1830. if(accept == 0)
  1831. {
  1832. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  1833. GtkWidget *warning = gtk_message_dialog_new(parent, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Userul/parola nu se potrivesc!");
  1834. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  1835. gtk_dialog_run(GTK_DIALOG(warning));
  1836. gtk_widget_destroy(warning);
  1837. }
  1838.  
  1839. else if(accept == 1)
  1840. {
  1841. g_print("Felicitari te-ai logat cu succes adminule! \n");
  1842.  
  1843. gtk_widget_destroy(GTK_WIDGET(parent));
  1844.  
  1845. GtkWidget *meniu_admin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1846. g_signal_connect(GTK_WINDOW(meniu_admin), "delete-event", G_CALLBACK(quit_meniu), meniu_admin);
  1847. gtk_window_set_default_size(GTK_WINDOW(meniu_admin), 400, 400);
  1848. gtk_window_set_title(GTK_WINDOW(meniu_admin), "TopMusic");
  1849.  
  1850. GtkWidget *sterge_melodie, *blocheaza_user, *accepta_admin;
  1851. GtkWidget *label = gtk_label_new("Alege una din urmatoarele optiuni: ");
  1852. GtkWidget *quit = gtk_button_new_with_label("Quit");
  1853. sterge_melodie = gtk_button_new_with_label("Sterge o melodie ");
  1854. blocheaza_user = gtk_button_new_with_label("Blocheaza un user");
  1855. accepta_admin = gtk_button_new_with_label("Accepta un admin ");
  1856. GtkWidget *adauga_gen = gtk_button_new_with_label("Adauga gen ");
  1857.  
  1858. GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  1859. gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 10);
  1860. gtk_box_pack_start(GTK_BOX(box), blocheaza_user,TRUE, TRUE, 10);
  1861. gtk_box_pack_start(GTK_BOX(box), sterge_melodie, TRUE, TRUE, 10);
  1862. gtk_box_pack_start(GTK_BOX(box), accepta_admin, TRUE, TRUE, 10);
  1863. gtk_box_pack_start(GTK_BOX(box), adauga_gen, TRUE, TRUE, 10);
  1864. gtk_box_pack_start(GTK_BOX(box), quit, TRUE, TRUE, 10);
  1865.  
  1866. g_signal_connect(GTK_BUTTON(blocheaza_user), "clicked", G_CALLBACK(on_blocheaza_user), meniu_admin);
  1867. g_signal_connect(GTK_BUTTON(accepta_admin), "clicked", G_CALLBACK(on_accepta_admin), meniu_admin);
  1868. g_signal_connect(GTK_BUTTON(quit), "clicked", G_CALLBACK(quit_out), meniu_admin);
  1869. g_signal_connect(GTK_BUTTON(sterge_melodie), "clicked", G_CALLBACK(on_sterge_melodie), meniu_admin);
  1870. g_signal_connect(GTK_BUTTON(adauga_gen), "clicked", G_CALLBACK(on_adauga_gen), meniu_admin);
  1871. gtk_container_add(GTK_CONTAINER(meniu_admin), box);
  1872.  
  1873.  
  1874.  
  1875. gtk_widget_show_all(meniu_admin);
  1876. }
  1877.  
  1878. }
  1879. }
  1880.  
  1881. static void inregistrare_admin(GtkButton *button, gpointer menu)
  1882. {
  1883. GtkWindow *main_menu = menu;
  1884.  
  1885. gtk_widget_destroy(GTK_WIDGET(main_menu));
  1886.  
  1887. GtkWidget *inreg_admin;
  1888. inreg_admin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1889. gtk_window_set_default_size(GTK_WINDOW(inreg_admin), 400, 400);
  1890. gtk_window_set_title(GTK_WINDOW(inreg_admin), "TopMusic");
  1891.  
  1892. GtkWidget *name_entry, *pass_entry, *label_name, *label_password, *label_re, *re_pass_entry, *submit;
  1893. name_entry = gtk_entry_new();
  1894. pass_entry = gtk_entry_new();
  1895. label_name = gtk_label_new("Introduceti numele :");
  1896. label_password = gtk_label_new("Introduceti parola :");
  1897. label_re = gtk_label_new("Reintroduceti parola :");
  1898. re_pass_entry = gtk_entry_new();
  1899. submit = gtk_button_new_with_label("Submit");
  1900. GtkWidget *back = gtk_button_new_with_label("Back");
  1901. GtkWidget *label_mail, *entry_mail;
  1902. label_mail = gtk_label_new("Introduceti e-mailul");
  1903. entry_mail = gtk_entry_new();
  1904.  
  1905. GtkWidget *layout = gtk_layout_new(NULL, NULL);
  1906.  
  1907. gtk_layout_put(GTK_LAYOUT(layout), label_name, 10, 30);
  1908. gtk_layout_put(GTK_LAYOUT(layout), name_entry, 180, 25);
  1909.  
  1910. gtk_layout_put(GTK_LAYOUT(layout), label_mail, 10, 70);
  1911. gtk_layout_put(GTK_LAYOUT(layout), entry_mail, 180, 65);
  1912.  
  1913. gtk_layout_put(GTK_LAYOUT(layout), label_password, 10, 110);
  1914. gtk_layout_put(GTK_LAYOUT(layout), pass_entry, 180, 105);
  1915. gtk_layout_put(GTK_LAYOUT(layout), label_re, 10, 150);
  1916. gtk_layout_put(GTK_LAYOUT(layout), re_pass_entry, 180, 145);
  1917. gtk_layout_put(GTK_LAYOUT(layout), submit, 285, 185);
  1918. gtk_layout_put(GTK_LAYOUT(layout), back, 10, 185);
  1919. gtk_container_add(GTK_CONTAINER(inreg_admin), layout);
  1920.  
  1921.  
  1922. g_object_set_data(G_OBJECT(submit), "user", name_entry);
  1923. g_object_set_data(G_OBJECT(submit), "pass", pass_entry);
  1924. g_object_set_data(G_OBJECT(submit), "re_pass", re_pass_entry);
  1925. g_object_set_data(G_OBJECT(submit), "parent", inreg_admin);
  1926. g_object_set_data(G_OBJECT(submit), "mail", entry_mail);
  1927. g_signal_connect(GTK_BUTTON(submit), "clicked", G_CALLBACK(on_submit_inregistrare_admin), submit);
  1928. g_signal_connect(GTK_BUTTON(back), "clicked", G_CALLBACK(back_to_menu), inreg_admin);
  1929.  
  1930. gtk_widget_show_all(inreg_admin);
  1931.  
  1932.  
  1933. }
  1934.  
  1935. static void login_admin(GtkButton *button, gpointer menu)
  1936. {
  1937. GtkWindow *main_menu = menu;
  1938.  
  1939. gtk_widget_destroy(GTK_WIDGET(main_menu));
  1940.  
  1941. GtkWidget *log_admin;
  1942. log_admin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1943. gtk_window_set_default_size(GTK_WINDOW(log_admin), 400, 400);
  1944. gtk_window_set_title(GTK_WINDOW(log_admin), "TopMusic");
  1945.  
  1946. GtkWidget *user, *parola, *user_label, *parola_label, *logare;
  1947. user = gtk_entry_new();
  1948. parola = gtk_entry_new();
  1949. user_label = gtk_label_new("Introduceti numele :");
  1950. parola_label = gtk_label_new("Introduceti parola :");
  1951. logare = gtk_button_new_with_label("Logare");
  1952.  
  1953. GtkWidget *layout = gtk_layout_new(NULL, NULL);
  1954. GtkWidget *back = gtk_button_new_with_label("Back");
  1955. gtk_layout_put(GTK_LAYOUT(layout), user_label, 10, 30);
  1956. gtk_layout_put(GTK_LAYOUT(layout), user, 180, 25);
  1957. gtk_layout_put(GTK_LAYOUT(layout), parola_label, 10, 70);
  1958. gtk_layout_put(GTK_LAYOUT(layout), parola, 180, 65);
  1959. gtk_layout_put(GTK_LAYOUT(layout), logare, 285, 105);
  1960. gtk_layout_put(GTK_LAYOUT(layout), back, 10, 105);
  1961.  
  1962. gtk_container_add(GTK_CONTAINER(log_admin), layout);
  1963.  
  1964. g_object_set_data(G_OBJECT(logare), "user", user);
  1965. g_object_set_data(G_OBJECT(logare), "pass", parola);
  1966. g_object_set_data(G_OBJECT(logare), "parent", log_admin);
  1967. g_signal_connect(GTK_BUTTON(logare), "clicked", G_CALLBACK(on_log_admin), logare);
  1968. g_signal_connect(GTK_BUTTON(back), "clicked", G_CALLBACK(back_to_menu), log_admin);
  1969.  
  1970. gtk_widget_show_all(log_admin);
  1971. }
  1972. static void inregistrare_utilizator(GtkButton *button, gpointer menu)
  1973. {
  1974. GtkWindow *main_menu = menu;
  1975.  
  1976. gtk_widget_destroy(GTK_WIDGET(main_menu));
  1977.  
  1978. GtkWidget *inreg_user;
  1979. inreg_user = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1980. gtk_window_set_default_size(GTK_WINDOW(inreg_user), 400, 400);
  1981. gtk_window_set_title(GTK_WINDOW(inreg_user), "TopMusic");
  1982.  
  1983. GtkWidget *label_nume, *entry_nume, *label_pass, *entry_pass, *label_re_pass, *entry_re_pass, *submit;
  1984. label_nume = gtk_label_new("Introduceti numele :");
  1985. label_pass = gtk_label_new("Introduceti parola :");
  1986. label_re_pass = gtk_label_new("Reintroduceti parola :");
  1987. entry_nume = gtk_entry_new();
  1988. entry_pass = gtk_entry_new();
  1989. entry_re_pass = gtk_entry_new();
  1990. submit = gtk_button_new_with_label("Submit");
  1991.  
  1992.  
  1993. GtkWidget *layout = gtk_layout_new(NULL, NULL);
  1994. GtkWidget *back = gtk_button_new_with_label("Back");
  1995.  
  1996. gtk_layout_put(GTK_LAYOUT(layout), label_nume, 10, 30);
  1997. gtk_layout_put(GTK_LAYOUT(layout), entry_nume, 180, 25);
  1998. gtk_layout_put(GTK_LAYOUT(layout), label_pass, 10, 70);
  1999. gtk_layout_put(GTK_LAYOUT(layout), entry_pass, 180, 65);
  2000. gtk_layout_put(GTK_LAYOUT(layout), label_re_pass, 10, 110);
  2001. gtk_layout_put(GTK_LAYOUT(layout), entry_re_pass, 180, 105);
  2002. gtk_layout_put(GTK_LAYOUT(layout), submit, 285, 145);
  2003. gtk_layout_put(GTK_LAYOUT(layout), back, 10, 145);
  2004.  
  2005. gtk_container_add(GTK_CONTAINER(inreg_user), layout);
  2006.  
  2007. g_object_set_data(G_OBJECT(submit), "nume", entry_nume);
  2008. g_object_set_data(G_OBJECT(submit), "parola", entry_pass);
  2009. g_object_set_data(G_OBJECT(submit), "re_pass", entry_re_pass);
  2010. g_object_set_data(G_OBJECT(submit), "parent", inreg_user);
  2011.  
  2012. g_signal_connect(GTK_BUTTON(submit), "clicked", G_CALLBACK(on_inregistrare_user), submit);
  2013. g_signal_connect(GTK_BUTTON(back), "clicked", G_CALLBACK(back_to_menu), inreg_user);
  2014.  
  2015. gtk_widget_show_all(inreg_user);
  2016. }
  2017. static void logare_utilizator(GtkButton *button, gpointer menu)
  2018. {
  2019. GtkWindow *main_menu = menu;
  2020.  
  2021. gtk_widget_destroy(main_menu);
  2022.  
  2023. GtkWidget *logare_user;
  2024. logare_user = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2025. gtk_window_set_default_size(GTK_WINDOW(logare_user), 400, 400);
  2026. gtk_window_set_title(GTK_WINDOW(logare_user), "TopMusic");
  2027.  
  2028. GtkWidget *label_nume, *label_pass, *entry_nume, *entry_pass, *logare;
  2029. label_nume = gtk_label_new("Introduceti numele :");
  2030. label_pass = gtk_label_new("Introduceti parola :");
  2031. entry_nume = gtk_entry_new();
  2032. entry_pass = gtk_entry_new();
  2033. logare = gtk_button_new_with_label("Logare");
  2034.  
  2035. GtkWidget *layout = gtk_layout_new(NULL, NULL);
  2036. GtkWidget *back = gtk_button_new_with_label("Back");
  2037. gtk_layout_put(GTK_LAYOUT(layout), label_nume, 10, 30);
  2038. gtk_layout_put(GTK_LAYOUT(layout), entry_nume, 180, 25);
  2039. gtk_layout_put(GTK_LAYOUT(layout), label_pass, 10, 70);
  2040. gtk_layout_put(GTK_LAYOUT(layout), entry_pass, 180, 65);
  2041. gtk_layout_put(GTK_LAYOUT(layout), logare, 285, 105);
  2042. gtk_layout_put(GTK_LAYOUT(layout), back, 10, 105);
  2043.  
  2044. gtk_container_add(GTK_CONTAINER(logare_user), layout);
  2045.  
  2046. g_object_set_data(G_OBJECT(logare), "nume", entry_nume);
  2047. g_object_set_data(G_OBJECT(logare), "parola", entry_pass);
  2048. g_object_set_data(G_OBJECT(logare), "parent", logare_user);
  2049.  
  2050. g_signal_connect(GTK_BUTTON(logare), "clicked", G_CALLBACK(on_logare_user), logare);
  2051. g_signal_connect(GTK_BUTTON(back), "clicked", G_CALLBACK(back_to_menu), logare_user);
  2052.  
  2053. gtk_widget_show_all(logare_user);
  2054. }
  2055. static void quit_out(GtkButton *button, gpointer menu)
  2056. {
  2057. int size = strlen("quit");
  2058. if(write(sd, &size, sizeof(int)) <= 0)
  2059. {
  2060. perror("Eroare la write() catre server");
  2061. return errno;
  2062. }
  2063. if(write(sd, "quit", sizeof(int)) <= 0)
  2064. {
  2065. perror("Eroare la write() catre server");
  2066. return errno;
  2067. }
  2068. GtkWindow *main_menu = menu;
  2069. gtk_widget_destroy(GTK_WIDGET(main_menu));
  2070. close(sd);
  2071. }
  2072.  
  2073. static void on_connect(GtkButton *button, GObject *context_object)
  2074. {
  2075. GtkEntry *ip_entry = g_object_get_data(context_object, "ip-entry");
  2076. GtkEntry *port_entry = g_object_get_data(context_object, "port-entry");
  2077. GtkWindow *page_1 = g_object_get_data(context_object, "page_1");
  2078. // int sd; // descriptorul de socket
  2079. struct sockaddr_in server; // structura folosita pentru conectare
  2080.  
  2081. /* stabilim portul */
  2082. int port = atoi (gtk_entry_get_text(port_entry));
  2083.  
  2084. /* cream socketul */
  2085. if ((sd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
  2086. {
  2087. perror ("Eroare la socket().\n");
  2088. return errno;
  2089. }
  2090.  
  2091. /* umplem structura folosita pentru realizarea conexiunii cu serverul */
  2092. /* familia socket-ului */
  2093. server.sin_family = AF_INET;
  2094. /* adresa IP a serverului */
  2095. server.sin_addr.s_addr = inet_addr(gtk_entry_get_text(ip_entry));
  2096. /* portul de conectare */
  2097. server.sin_port = htons (port);
  2098.  
  2099. /* ne conectam la server */
  2100. int ok = 1;
  2101. if (connect (sd, (struct sockaddr *) &server,sizeof (struct sockaddr)) == -1)
  2102. {
  2103. GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
  2104. GtkWidget *warning = gtk_message_dialog_new(page_1, flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Eroare la conectare!");
  2105. gtk_window_set_title(GTK_WINDOW(warning), "WARNING!");
  2106. gtk_dialog_run(GTK_DIALOG(warning));
  2107. gtk_widget_destroy(warning);
  2108. ok = 0;
  2109. }
  2110.  
  2111. if(ok){
  2112. gtk_widget_destroy(page_1);
  2113. GtkWidget *main_menu = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2114. gtk_window_set_default_size(GTK_WINDOW(main_menu), 400, 400);
  2115. gtk_window_set_title(GTK_WINDOW(main_menu), "TopMusic");
  2116.  
  2117. GtkWidget *label, *inreg_admin, *inreg_user, *logare_admin, *logare_user, *quit;
  2118.  
  2119. label = gtk_label_new("Alege una din optiunile de mai jos:");
  2120. inreg_admin = gtk_button_new_with_label("Inregistrare ca admin");
  2121. inreg_user = gtk_button_new_with_label("Inregistrare");
  2122. logare_admin = gtk_button_new_with_label("Logare ca admin");
  2123. logare_user = gtk_button_new_with_label("Logare");
  2124. quit = gtk_button_new_with_label("Quit");
  2125.  
  2126. GtkWidget *box;
  2127. box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  2128.  
  2129. gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 10);
  2130. gtk_box_pack_start(GTK_BOX(box), inreg_admin, TRUE, TRUE, 10);
  2131. gtk_box_pack_start(GTK_BOX(box), logare_admin, TRUE, TRUE, 10);
  2132. gtk_box_pack_start(GTK_BOX(box), inreg_user, TRUE, TRUE, 10);
  2133. gtk_box_pack_start(GTK_BOX(box), logare_user, TRUE, TRUE, 10);
  2134. gtk_box_pack_start(GTK_BOX(box), quit, TRUE, TRUE, 10);
  2135.  
  2136.  
  2137. g_signal_connect(GTK_BUTTON(inreg_admin), "clicked", G_CALLBACK(inregistrare_admin), main_menu);
  2138. g_signal_connect(GTK_BUTTON(logare_admin), "clicked", G_CALLBACK(login_admin), main_menu);
  2139. g_signal_connect(GTK_BUTTON(inreg_user), "clicked", G_CALLBACK(inregistrare_utilizator), main_menu);
  2140. g_signal_connect(GTK_BUTTON(logare_user), "clicked", G_CALLBACK(logare_utilizator), main_menu);
  2141. g_signal_connect(GTK_BUTTON(quit), "clicked", G_CALLBACK(quit_out), main_menu);
  2142.  
  2143. gtk_container_add(GTK_CONTAINER(main_menu), box);
  2144. gtk_widget_show_all(main_menu);
  2145. }
  2146.  
  2147. }
  2148.  
  2149. int main(int argc, char *argv[])
  2150. {
  2151. gtk_init(&argc, &argv);
  2152.  
  2153. GtkWidget *ip, *port, *ip_entry, *port_entry;
  2154.  
  2155. GtkWidget *page_1 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  2156. gtk_window_set_default_size(GTK_WINDOW(page_1), 400, 400);
  2157. gtk_window_set_title(GTK_WINDOW(page_1), "TopMusic");
  2158. ip = gtk_label_new("IP");
  2159. ip_entry = gtk_entry_new();
  2160. port = gtk_label_new("Port");
  2161. port_entry = gtk_entry_new();
  2162.  
  2163. GtkWidget *grid = gtk_grid_new();
  2164.  
  2165. gtk_grid_attach(GTK_GRID(grid), ip, 1, 1, 1, 1);
  2166. gtk_grid_attach(GTK_GRID(grid), port, 1, 2, 1, 1);
  2167. gtk_grid_attach(GTK_GRID(grid), ip_entry, 2, 1, 1, 1);
  2168. gtk_grid_attach(GTK_GRID(grid), port_entry, 2, 2, 1, 1);
  2169.  
  2170. GtkWidget *connect;
  2171. connect = gtk_button_new_with_label("Connect");
  2172.  
  2173. gtk_grid_attach(GTK_GRID(grid), connect, 2, 3, 1, 1);
  2174.  
  2175. g_object_set_data(G_OBJECT(connect), "ip-entry", ip_entry);
  2176. g_object_set_data(G_OBJECT(connect), "port-entry", port_entry);
  2177. g_object_set_data(G_OBJECT(connect), "page_1", page_1);
  2178. g_signal_connect(GTK_BUTTON(connect), "clicked", G_CALLBACK(on_connect), connect);
  2179.  
  2180.  
  2181. gtk_container_add(GTK_CONTAINER(page_1), grid);
  2182.  
  2183. gtk_widget_show_all(page_1);
  2184.  
  2185. gtk_main();
  2186.  
  2187. return 0;
  2188. }
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!