Take Notes, specifica e richieste
burton
Oggi abbiamo mandato al specifica al professore e questa è la
risposta:
---------
Come vi dicevo a lezione l'idea in generale va bene.
In realt‡ il software descritto nella specifica attuale, pur essendo
molto simpatico, rimane un po' fuori dallo spirito del progetto, che
voleva spingervi a guardare all'interno del codice sorgente e del
processo di sviluppo di un sistema operativo aperto.
Per sistemare le cose, considerato anche il volume richiesto da un
progetto di 3 persone, aggiungo alle vostre specifiche una
funzionalit‡
di livello un po' pi˘ basso.
- I post-it possono essere incollati al desktop del sistema operativo,
o
ad una delle finestre aperte al momento.
- Un post-it incollato ad una finestra segue il ciclo di vita della
finestra stessa. Quando la finestra viene minimizzata, il post-it
viene
nascosto. Quando la finestra viene ripristinata, il post-it viene
nuovamente mostrato. Quando la finestra viene spostata, il post-it si
sposta (sincronizzato con l'angolo in alto a sinistra della finestra).
Quando la finestra viene chiusa il post-it viene nascosto (e non
cancellato). Quando viene aperta una finestra con le stesse
caratteristiche di quella chiusa (per es. titolo e applicazione), il
post-it viene nuovamente mostrato.
Come avrete capito in questo caso si tratta di dare un'occhiata al
codice del vostro window manager e probabilmente aggiungere alle
funzionalit‡ di minimizzazione, restore, chiusura, apertura,
spostamento
del wm la chiamata al vostro programma.
In caso di modifica al wm, deve essere possibile compilare il vostro
programma in due modalit‡: una che funzioni con il wm standard (e che
implementi solo le funzionalit‡ correnti) ed una che funzioni con il
wm
esteso.
Fatemi sapere cosa ne pensate.
Attendo una versione aggiornata delle specifiche per la conferma
definitiva.
Massimo Tisi
---------
Apparte che lui parla genericamente di un Window Manager (alla linux),
ma quello che lui chiede mi sembra abbastanza infattibile, appoggiare
un replicant sul desktop è okay, ma integrarlo in un altra
applicazione vorrebbe dire mettere mano al cuore di haiku,no ?
E' da poco che mi sono buttato nella programmazione BeOS, ma per me
quello che lui chiama WM per me è app_server. Quindi fondamentalmente
vuole che io metta mano all'app_server,giusto ?
Voi cosa ne pensate ?
ciao e grazie,
Ilio.
Giuseppe Gargaro
Ciao Giuseppe
Andrea
ragazzi di auckland vi potrebbe aiutare, almeno per quanto riguarda
l'app_server
http://www.freelists.org/post/haiku-development/Two-successful-final-year-projects
http://www.cs.auckland.ac.nz/~lutteroth/videos/stack-and-tile.html
e sicuramente Stippi vi potrà aiutare senza problemi :)
Andrea
Il 27 marzo 2009 13.21, Giuseppe Gargaro <giuseppe...@gmail.com>
ha scritto:
Pier Luigi Fiorini
> non vorrei dire una cazzata ma forse il progetto universitario dei
> ragazzi di auckland vi potrebbe aiutare, almeno per quanto riguarda
> l'app_server
>
> http://www.freelists.org/post/haiku-development/Two-successful-final-year-projects
> http://www.cs.auckland.ac.nz/~lutteroth/videos/stack-and-tile.html
>
> e sicuramente Stippi vi potrà aiutare senza problemi :)
Qui ho visto un .rdef per il replicant di NetPositive:
http://dev.osdrawer.net/repositories/entry/behappy/trunk/NetPositiveReplicant.rdef
Si trova anche quello di NetSurf, però purtroppo non è una cosa che ho
fatto ad ogni modo è possibile inserire un replicant dentro una finestra
dell'applicazione, il problema è che l'applicazione deve prevederlo temo.
burton
realtà è che il programma di post-it tenga traccia degli applicativi
aperti e, nel caso venga aperto un programma su cui è associato un
post-it, crei automaticamente la finestra posizionandola sopra
l'applicativo in questione.
A tal proposito ho visto (grazie ad una dritta di emitrax) che BRoster
fa al caso nostro, ho però problemi con questo stralcio di codice:
#include <iostream.h>
#include <List.h>
#include <Roster.h>
int main(){
//BList conterrà la lista dei miei programmi in esecuzione
//who conterrà il team_id dell'applicativo da analizzare
//app_info conterrà le informazioni dell'applicativo che voglio
//analizzare
BList *aList = new BList;
app_info *appInfo;
team_id who;
be_roster->GetAppList(aList); //ottengo la lista delle apps
who = (team_id)aList->ItemAt(1); //1 è aribitrario
be_roster->GetRunningAppInfo(who,appInfo);
return 0;
}
che dovrebbe riporre in appInfo le informazioni riguardo alla prima
applicazione nella lista contenuta in aList. IL warning è il
seguente:
Warning : /boot/home/Progetti/BRoster/Arrosto/main.cpp: In function
`int main()':
`struct app_info * appInfo' might be used uninitialized in this
function
main.cpp line 13 app_info *appInfo;
e l'applicativo va subito in crash. Qualcuno sa darmi una mano :( ?
grazie e ciao!
Casalinuovo Dario
: )
Pier Luigi Fiorini
> ho avuto un'altro scambio epistolare con il prof. Ciò che lui vuole in
> realtà è che il programma di post-it tenga traccia degli applicativi
> aperti e, nel caso venga aperto un programma su cui è associato un
> post-it, crei automaticamente la finestra posizionandola sopra
> l'applicativo in questione.
> A tal proposito ho visto (grazie ad una dritta di emitrax) che BRoster
> fa al caso nostro, ho però problemi con questo stralcio di codice:
>
> #include <iostream.h>
> #include <List.h>
> #include <Roster.h>
>
> int main(){
>
> //BList conterrà la lista dei miei programmi in esecuzione
> //who conterrà il team_id dell'applicativo da analizzare
> //app_info conterrà le informazioni dell'applicativo che voglio
> //analizzare
>
> BList *aList = new BList;
> app_info *appInfo;
> team_id who;
>
>
> be_roster->GetAppList(aList); //ottengo la lista delle apps
> who = (team_id)aList->ItemAt(1); //1 è aribitrario
>
> be_roster->GetRunningAppInfo(who,appInfo);
>
> return 0;
>
> }
>
GetRunningAppInfo() torni la struttura appInfo nel secondo parametro,
devi quindi allocare diversamente appInfo e passare la reference.
Metto solo le righe rilevanti
// altro codice
app_info appInfo; // niente puntatore
// altro codice
be_roster->GetRunningAppInfo(who, &appInfo);
Andrea Anzani
Pier Luigi Fiorini
solo tu avessi allocato appInfo così come suggeriva Dario:
app_info *appInfo = new app_info();
Ricordandoti però di fare la delete appInfo dopo averlo utilizzato per
l'ultima volta.
Poi se vogliamo essere paranoici e segaioli in C++ quando allochi con
malloc se sei in out of memory ti spara un'eccezione che dovresti
trappare, oppure se vuoi controllare che il puntatore sia NULL devi fare:
app_info *appInfo = new(std::nothrow) app_info();
if (appInfo == NULL)
printf("out of memory\n");
// uso appInfo.........
delete appInfo;
Pier Luigi Fiorini
>
>
> > BList *aList = new BList;
> > app_info *appInfo;
> > team_id who;
> >
> >
> > be_roster->GetAppList(aList); //ottengo la lista delle apps
> > who = (team_id)aList->ItemAt(1); //1 è aribitrario
> >
> > be_roster->GetRunningAppInfo(who,appInfo);
> >
> GetRunningAppInfo() torni la struttura appInfo nel secondo parametro,
> devi quindi allocare diversamente appInfo e passare la reference.
> Metto solo le righe rilevanti
>
> // altro codice
>
> app_info appInfo; // niente puntatore
>
> // altro codice
>
>
> be_roster->GetRunningAppInfo(who, &appInfo);
>
>
> Forse serve anche che la tua applicazione sia una BApplication (ma non
> ne sono sicuro)
> in ogni caso aggiungi
Non è indispensabile in questo caso, ma sono sicuro che gli servirà man
mano che l'applicazione diventa complessa ;-)
Andrea
> Per il resto la tua applicazione sembra simile a Moe un programmina vecchio
> di beos che permetteva di avere una mascot seduta sul bordo della finestra
> attiva.
> Io conosco solo questo link http://bebits.com/app/1995
> anche se mi sembra tutto dead.. prova a cercare su BeShare o chiedi in giro
> se qualcuno ha da qualche parte i sorgenti..
> Andrea.
http://www.haikuware.com/start-download/entertainment/other/moe
la trovi qui :)
Andrea B.
burton
che figura da cioccolataio :P
ora provo e vi faccio sapere!
On 30 Mar, 19:56, Andrea <bernardi.and...@gmail.com> wrote:
burton
#include <iostream.h>
#include <List.h>
#include <Roster.h>
int main(){
//BList conterrà la lista dei miei programmi in esecuzione
//who conterrà il team_id dell'applicativo da analizzare
//app_info conterrà le informazioni dell'applicativo che voglio
BList *aList = new BList;
team_id who;
int32 i=0;
be_roster->GetAppList(aList); //ottengo la lista delle apps
who = (team_id)aList->ItemAt(i);
be_roster->GetRunningAppInfo(who,appInfo);
cout << "signature: " << appInfo->signature << endl;
}
return 0;
}
Moe me lo ricordo, era simpatico ;) ora bisogna trovare un modo di
lanciare un thread separato che controlli (possibilmente in modo
efficiente) tra la lista delle applicazioni aperte quelle a cui va
associata una nota precedentemente inserita!
Grazie a tutti per il feedback su un errore così stupido!
Notte,
Ilio.
burton
volevo un vostro parere su una idea che ci è venuuta riguardo la
strutturazione del programma. Dato che avremo bisogno di un programma
che nella peggiore delle ipotesi faccia polling per capire gli
applicativi aperti e visualizzare i post-it relativi e di un altro
programma per invece creare nuove note, pensavamo di strutturare il
tutto mediante paradigma client/server. Una cosa tipo note_client e
note_server (come l'im_kit insomma). In maniera tale che il server si
occupi di gestire questi aspetti di "back-end" e mediante il client
possa invece inserire nuove note.
In questo modo l'impressione è quella di essere più coerenti con la
struttura di BeOS/Haiku. L'applicativo di client e l'applicativo
server si scambieranno messaggi BMessage per collaborare tra di loro
giusto ? (domanda stupida, ma qui stiamo ancora tentando di entrare
nella filosofia di programmazione beossiana)
Grazie per l'aiuto,
ciao,
Ilio.
Salvatore Benedetto
>
> Ciao a tutti,
>
Ciao Ilio ;-)
>
> volevo un vostro parere su una idea che ci è venuuta riguardo la
> strutturazione del programma. Dato che avremo bisogno di un programma
> che nella peggiore delle ipotesi faccia polling per capire gli
> applicativi aperti e visualizzare i post-it relativi e di un altro
> programma per invece creare nuove note, pensavamo di strutturare il
> tutto mediante paradigma client/server. Una cosa tipo note_client e
> note_server (come l'im_kit insomma). In maniera tale che il server si
> occupi di gestire questi aspetti di "back-end" e mediante il client
> possa invece inserire nuove note.
>
[parentesi]
Allora, come tu ben sai, mi interessa particolarmente molto il design
dell'applicazione perche sara' oggetto del mio esame di Ingegneria del Software,
nel quale faro' appunto il design (l'implementazione la faro' dopo per
i fatti miei
se non riusciremo a coordinarci) di una applicazione come Tomboy per Haiku.
Iniziero' con il mio collega settimana prossima.
[/parentesi]
Personalmente non sono molto incline alla struttura client/sever. Mi sa molto
di linux e non ne vedo la necessita'. La prima cosa che mi viene in mente invece
e' definire in maniera chiara un oggetto che gestisca la nota, con tutte le sue
funzionalita' (scrittura/lettura su disco ad esempio). Dopo credo sia
necessario un
gestore delle note, che magari esporti delle API (come tomboy) per
poter scrivere
degli addon. Ed infine un visualizzatore di note con relativa preflet.
Per quanto riguarda la possibilita' di "attaccare" le note su una
qualsiasi finestra
io la vedo piu come una funzionalita' dell'application server che del
post-it (HaikuNotes vi
garba ?). Magari si puo pensare ad un addon per l'app_server
(HaikuNotes-Addon) che
conosce le API del gestore delle note, e molto banalmante dovrebbe
salvarsi l'ID della
finestra (non conosco i dettagli della gesitone delle finestre ma
credo sia utile guardare
il progetto dell universita' dell'ackland), l'ID della nota e la
posizione nel quale attaccare
la nota. Teoriacamente (di programmazione BeOS ne so quanto te quindi
potrei dire
castronerie), in questo modo, il visualizzatore di note quando fai il
drag and drop sulla
finestra, manda un BMessage definito da lui e che soltanto l'addon
dell'app_server conosce ed
intercetta, il quale si occupera' della gestione della visualizzazione
della nota.
In questo modo non c'e' bisogno di polling, di sapere quante finistre
sono aperte, etc .. etc..
Adesso dovrebbe intervenire qualcuno piu esperto di BeOS come Andrea o
Stefano e correggermi. :-)
Saluti,
Salvatore
Andrea Anzani
Ciao,
sinceramente, IMHO, non vedo la necessità di avere un sistema client/server.. piu' che altro perché in questo caso ci sarebbe un server per gestire uno ed un solo client..
Ma ad ogni modo, che sia un server o un BLooper è la stessa cosa.. in ogni caso tra due entità indipendenti ci sarà uno scambio asincrono di BMessage..
Andrea.
Casalinuovo Dario
carino aggiungere un metodo a BWindow per attaccare due finestre?
burton
qualcuno ha una più pallida idea di come fare un sistema di controllo
dell'orario che non sia un polling infinito dell'orario di sistema.
L'intento è quello di tentar di capire come implementare la
funzionalità di post-it con allarme. Associata un ora alla nota, come
far si che il programma si accorga del fatto che l'ora di trillare è
giunta :D (che non sia polling per l'appunto) ?
grazie e ciao!
Salvatore Benedetto
Andrea Anzani
prova a vedere questa classe se ti può aiutare:
http://www.haiku-os.org/legacy-docs/bebook/BMessageRunner_Overview.html
burton
On 6 Apr, 16:49, Andrea Anzani <andrea.anz...@gmail.com> wrote:
> Il giorno 6 aprile 2009 16.27, burton <ilio.cata...@gmail.com> ha scritto:
>
>
i luv u so much! ;)
burton
grafici ?
i file sono sul repository di OSDrawer, compreso il file di progetto
BeIDE (alla fine dovremo imparare ad usare jam e creare un jamfile).
Se seleziono il testo succede il finimondo!
Metto le mani avanti, il codice è da ripulire :D
ciao e grazie!
Ilio.