@TCH:
És hogyan lehet. Mivel csináltad? Meg mire, Qt-re vagy GTK-ra?

@TCH:
A randomot minek? Jó az sima C fájlban is, nincs benne egyetlen cucc sem, amit föltétlenül meg kéne védeni a közvetlen hozzáféréstől. A forgatórutinokat is lehet nyugodtan hívogatni, ha valaki forgatni akar.

@kemi:
GTK. Próbálkoztam Qt-vel, de nem nagyon jött be nekem. Mindenből saját típusa van, ide-oda kell castolgatni a Qt-s meg a standard c-s típusok között, meg az eseménykezelés is elég furán van megoldva.

@kemi:
Standard. C fájlokat nem nagyon szoktak inkludálgatni.

@kemi:
Jó lenne bencsmárkolni, de az itt fent levő bugos, és nincs már meg nekem a forrása, meg nem fair egy wineból futó valamit egy natív linuxos programmal összehasonlítani. :P

@TCH:
Typedeffel nem lehet ezt megoldani?

@TCH:
a GTK tényleg akkora hányadék, mint ahogy mondják, vagy eltúlozzák?

@kemi:
Nem, mert objektumorientáltan van megoldva. Metódushívásokkal lehet konvertálgatni.

@kemi:
A GTK full C, és nem C++, (de van wrapper C++-hoz) és úgy még undorítóbban néz ki az OOP. :P

@TCH:
C-ben vannak ojjektumok? O_O Én azt hittem csak struct van.

@TCH:
Milyen GUI buildert használtál egyébként?

@kemi:
Úgy van, hogy bele van hekkelve az OOP. Van egy struct ami maga az objektumpéldány, benne vannak a mezők, a metódushívás meg egy függvény, ami megkapja cím szerint az objektumpéldányt.

void on_button_set_files_clicked(GtkWidget* widget, gpointer data) {
	GtkWidget* opendialog = gtk_file_chooser_dialog_new("Input file",
							    GTK_WINDOW(window),
							    GTK_FILE_CHOOSER_ACTION_OPEN,
							    GTK_STOCK_OPEN, GTK_RESPONSE_OK,
							    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
							    NULL);
	GtkResponseType open_response = gtk_dialog_run(GTK_DIALOG(opendialog));
	char* infile = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(opendialog));
	gtk_widget_destroy(opendialog);
	GtkWidget* savedialog = gtk_file_chooser_dialog_new("Output file",
							    GTK_WINDOW(window),
							    GTK_FILE_CHOOSER_ACTION_SAVE,
							    GTK_STOCK_SAVE, GTK_RESPONSE_OK,
							    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
							    NULL);
	GtkResponseType save_response = gtk_dialog_run(GTK_DIALOG(savedialog));
	char* outfile = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(savedialog));
	gtk_widget_destroy(savedialog);

	if (open_response == GTK_RESPONSE_OK && save_response == GTK_RESPONSE_OK) {
		gtk_entry_set_text(GTK_ENTRY(entry_infile), infile);
		gtk_entry_set_text(GTK_ENTRY(entry_outfile), outfile);
		files_set = 1;
	}
}

@TCH:
Jó, "tömör" kód.

@TCH:
Qt-ban hogy nézne ki ugyanez?

@TCH:
Miért kell a dialógusokat használat után törölni?

@kemi:
Az, de a C nyelv ilyen. :)

@kemi:
Ott a dialógusablakból egy QString-be kapod meg a fájlnevet. Amíg csak bele kell írni egy textboxba teljesen oké, de ha fel kell használni valami fájlművelethez, akkor már charstringbe kell konvertálni.

@kemi:
Addig nem záródik be az ablak amíg nem hívsz rá egy destroyt.

@TCH:
Már, ha C-t használsz és nem C++-t, ugye? Vagy C++-ban is konvertiren?

@TCH:
Hogyhogy? Lazarusban, Delphiben bezáródik, ha rábökök az OK vagy a kancsal gombra.

@TCH:
Meg ott annyi az egész, hogy If dialog_neve.Execute Then Begin és kinyitja, valamint csak akkor mászik be a lefuttatandó kódba, ha az OK-ra nyomtál (vagy ekvivalens műveletet végeztél, duplaklikk, ritörn, estébé).

GtkWidget* opendialog = gtk_file_chooser_dialog_new("Input file",
					            GTK_WINDOW(window),                     //hívó ablak
						    GTK_FILE_CHOOSER_ACTION_OPEN,           //fájlmegnyitó dialógusablak legyen
						    GTK_STOCK_OPEN, 1,                      //A GTK_STOCK_OPEN az éppen használt nyelv "megnyitás" stringjét rakja a gombra, ha ráklikkelsz 1-et ad vissza
						    GTK_STOCK_CANCEL, 0,                    //ugyanaz mégsére, 0-t fog visszaadni
						    NULL);                                  //listaterminátor

if (gtk_dialog_run(GTK_DIALOG(opendialog))) {
    .
    .
    .
}

@kemi:
C++ C-ben nem láttam még Qt kódot, viszont GTK-hoz nincs hivatalos C++ interfész.

@kemi:
Itt ha megbököd valamelyik gombot akkor visszaad egy response-t, de nyitva marad az ablak, amíg ki nem törlöd.

@kemi:
Lehet olyat csinálni

...

de én ragaszkodtam a standardhoz:

@TCH:
De neked egyébként most nem egy C++ beadandót kellett volna csinálni?

@TCH:
És nem lehet csak simán bezárni pl. close_dialog(faszom) paranccsal, muszáj törölni?

@kemi:
Az, de C++-ból simán lehet hivogatni a C-s rutinokat. Randán néz ki, de a Gtk-t így lehet megszólítani C++-ból a legegyszerűbben.

@kemi:
Meg szerintem memóriakihasználás szempontjából is jobb. Ha már úgyse használod többet, miért ne lehetne törölni? C-ben nincs szemétgyűjtő.

@Szőlősi Tibor @ Kiderült, hogy miért nem lehet 16 GB-os Surface-t kapni:
Az operációs rendszer felelős azért, hogy 32 GB-os a legkisebb Surface.

A Microsoft Surface teljes mértékben készen áll az előrendelésre, és miután az árak is tisztázásra kerültek, az is kiderült, hogy semmivel sem jobb vétel, mint az iPad, kivéve a memóriát illetően, ott ugyanis az Apple terméke hátrányban van. Vagy mégsem?

Így tehát a számok alapján joggal gondolhatja az egyszeri Surface vásárló, hogy mekkora jó biznisz 32 gigás táblagépet venni egy 16 gigás iPad áráért, egészen addig, míg ki nem derül, hogy a Surface-re telepített Windows RT helyigénye 12x akkora, mint az iOS-é, vagyis bő 12 GB.

Ez egy Ricardo Lopezhez, egy test managerhez intézett kérdésből derült ki, melyre azt a választ adta, hogy közel 20 GB hely kell a Windows RT-nek és az Office RT-nek. Ilyenformán tehát tulajdonképpen az iPad által kínált szabad kapacitás meghaladja a Surface-t, de ami leginkább zavarhatja a vásárlóközönséget, hogy ez az "aprócska" részlet eddig nem került napvilágra.

@TCH:
Dehát használod! Ha legközelebb megint arra a gombra bök, akkor megint fel kell, hogy jöjjön a dialógus; akkor megint létre kell hozni; nem egyszerűbb meghagyni és csak show/hide? Ha állandóan ugyanazt allokálod, meg szabadítod fel, az sem túl memóriabarát és még lassabb is. :P