Newsgroup: it.comp.programmare.win32
Titolo: exe che restituisce una stringa

Ciao... sto cercando di fare un programma che funzioni cosě:
    l'utente sta girando tra le pagine di un sito, che si linkano fra loro
tramite un exe. Nel senso che la "pagina1.html" linka a "mioprogramma
pagina2.html" e mioprogramma.exe apre la "pagina2.html".
    Ora, avevo pensato a due sistemi:
1) mioprogramma.exe RESTITUISCE il testo della pagina... come una pagina asp
(ah, purtroppo non posso usare asp...). Ma non ho proprio idea di come fare.
Navigando ho visto molti siti (x es. 
www.chl.it
) che "chiedono" le pagine ad
un exe server side che ne restituisce il testo al browser, ma non ho proprio
idea su come realizzarli.
2) mioprogramma.exe LANCIA la pagina su Internet Explorer e gliela fa
aprire. Ho provato con l'API WinExec, ma senza risultato,
perché non so come lanciare iexplorer.exe e lanciando "iexplorer.exe
pagina2.html" non funziona.
Come potrei fare? E' possibile utilizzare il primo metodo?
Grazie 1000,
Paolo

 (ah, purtroppo non posso usare asp...). Ma non ho proprio idea di come
fare.
Se non puoi usare ASP, immagino vorrai usare CGI, la classica
"common gateway interface" (o sue versioni moderne e migliorate,
come FastCGI).  Chiedi dunque su it.comp.www.cgi, il gruppo
che e` appunto dedicato a questo tema.
Alex

 wrote in message
8js32k$had$1...@serv1.iunet.it...



Premesso che, a mio modestissimo parere, questo meccanismo di protezione è 
abbastanza inutile (basta avere un po' di pazienza o scrivere un 
programmino che si interfacci a IE (o a un altro browser) e scarichi tutto 
il contenuto in chiaro) e noioso per l'utente (se deve cambiare il disco 
fisso...).
Penso che non sia così complesso implementare un web server minimo che si 
limiti a decrittare le info e rimandarle al browser (utilizzando le url nel 
formato localhost:porta/url). L'unico requisito è la presenza del 
protocollo TCP/IP (che dovrebbe comunque essere richiesto anche dal 
browser). Il probabile vantaggio di questo approccio è l'indipendenza dal 
browser e la possibilità di condividere le pagine in rete (anche se il 
secondo vantaggio potrebbe essere un problema, visti i requisiti di 
partenza...).
-- 
Valter Minute
min...@inwind.it
 (the reply address of this message is invalid)

 partenza...).
Giusto.  Il desiderio di proteggere le proprie applicazioni (o,
qui, i propri dati) contro usi fuori licenza contrasta di solito
con i normali desideri di generalita` e flessibilita`.
Il mio suggerimento sarebbe dunque di rinunciare all'indipendenza
dal browser e sviluppare un controllo ActiveX che esegua la
decodifica desiderata e modifichi di conseguenza il documento
corrente (basta settarne la proprieta` outerHtml con l'intero
testo HTML da visualizzare).  Questo in effetti legherebbe le
cose a Internet Explorer, purche` purtroppo ancora oggi gli
altri browser non supportano bene le specifiche dell'HTML
dinamico del W3C (a quanto sento dire, neppure Mozilla nel suo
piu` recente beta/snapshot; come al solito, dunque, gli anti-MS
si stanno alacremente zappando i piedi, implementando un mucchio
di cose proprietarie e non-standard, e trascurando la piena e
corretta implementazione degli standard -- come se non fosse del
tutto ovvio che gli standard sono l'unica leva efficace contro
lo strapotere MS, sigh).
Comunque, se la browser-independence e` irrinunciabile, esistono
implementazioni di minima, facilmente adattabili ai tuoi scopi,
di serventi HTTP.  Le migliori, secondo me, sono quelle in Python
che sono distribuite come parte integrante della distribuzione
standard di Python stesso; la natura dinamica di Python rende
massimamente agevoli questo tipo di adattamenti.
Alex

 fare.
Come gia` ho detto in risposta all'ottima replica che ti ha dato
Valter, la prima e fondamentale scelta e` se tu possa legarti a
uno specifico browser (Internet Explorer 5; potrebbe bastare anche
il 4, ma il 5 e` piu` veloce e potente) oppure se fra i vincoli
sotto i quali lavori c'e` quello di garantire all'utente la
possibilita` di scegliere il browser che vuole (naturalmente
quest'ultima scelta permetterebbe anche all'utente di usare un
browser finto, o automatizzato, e farsi una copia integrale ma
decrittata del tuo sito-crittato).  Nel secondo caso devi fare un
microscopico server-http customizzato.
Nel primo caso, cioe` se ti va bene legarti a IE5, hai varie
possibilita`.  Attraverso COM, puoi connettere una tua applicazione
pilota mettendola in controllo dell'intera "navigazione", e fare
in essa il decrittaggio necessario; puoi anche usare "solo un
subset" delle funzionalita` IE5 ed inibire ad esempio, se vuoi,
il salvataggio delle pagine cosi` visualizzate.  Non c'e`
praticamente limite alla modularita` e customizzabilita` di
IE5; devi solo avere una discreta competenza di COM, Automation,
object-model dei documenti HTML (di quest'ultimo non ti serve
sapere molto per questa tua specifica applicazione, a dire il
vero).  C++ (specialmente Visual C++), Python, Visual Basic,
forniscono tutti ottimi ambienti di lavoro per queste cose (e
mi pare, ma non lo so in prima persona, che al giorno d'oggi
questo sia finalmente vero anche per gli ambienti Borland).
Alex

 trasbordare su un altro computer tutto il lavoro)
Inutile. Una volta che la pagina è visibile in chiaro sul browser 
basta salvarla.... Immagini comprese. Peccato.

 testo HTML da visualizzare).
Posso tranquillamente rinunciare all'indipendenza dal browser e legarmi ad
Internet Explorer 5.0. Il problema è che non so proprio come creare un
controllo ActiveX che modifichi il documento corrente... proprietà
outerHtml... arabo x me.. :-(
Grazie ancora a tutti per le risposte e scusate per l'OT su
it.comp.lang.c++,
Paolo

 vero).
Qui casca l'asino(= io). Purtroppo non ho *alcuna* esperienza in COM,
Automation ed object-model dei documenti HTML. So solo a grandi linee cosa
sono. Purtroppo per ora mi sono lambiccato il cervello solo con gestionali e
simili... Quanto mi ci vorrà a farmi una "discreta competenza" delle cose di
cui ho bisogno? E' molto complesso quello di cui avrei bisogno? Cosa dovrei
fare a grandi linee?
Grazie ancora per l'aiuto,
Paolo

 wrote in message
8jt71g$o8s$1...@fe2.cs.interbusiness.it...

Non necessariamente, perche`, come ho gia` spiegato, se si e`
disposti ad usare Internet Explorer 5 come unico browser
supportato, lo si puo` programmare e personalizzare in tanti,
ma tanti modi.  Fra le varie possibilita`, c'e` anche quella
di disabilitare il salvataggio, naturalmente.
Alex

 fare a grandi linee?
Se usi un linguaggio ragionevolmente facile e con un buon supporto
COM, come Python o Visual Basic, non e` poi tanto un'impresa,
specie se ti accontenti delle funzionalita` che hai piu` volte
specificato, senza pretese di fare qualcosa di piu` raffinato
tipo inibire il salvataggio, ecc ecc.
La cosa piu` rapida e` probabilmente in questo caso il Visual
Basic.  Da Project/References connetti la libreria di Internet
Explorer, ne gestisci gli eventi... non e` poi difficile.  Il
gruppo di visual basic puo` probabilmente supportarti, ma non
lo seguo direttamente, quindi non saprei...
Alex

 fare a grandi linee?
Rispondo nuovamente per mostrare l'esatto grado di semplicita`
cui si puo` giungere nella soluzione via COM e IE5.
Fai partire VB6, genera un nuovo "Standard .EXE", dai un
nome decente (tipo "Naviga") al progetto in project/properties
e alla Form, eventualmente poni Visible a False per la Form
(un dettaglio), View/Code, e immetti questo testo come Code
della Form...:
Option Explicit
Option Compare Text
Dim WithEvents Ie As InternetExplorer
Private Sub Form_Load()
    Set Ie = CreateObject("InternetExplorer.Application")
    Ie.Navigate "C:\Pippo.Htm"
    Ie.Visible = True
End Sub
Private Sub Ie_BeforeNavigate2(ByVal pDisp As Object, URL As Variant, _
    Flags As Variant, TargetFrameName As Variant, PostData As Variant, _
    Headers As Variant, Cancel As Boolean)
        If Right(URL, 4) = ".Pop" Then
            Cancel = True
            Dim sDoc As String
            sDoc = "<p>Ciao, sono " & URL & "<p>" & _
                "<p>prova <a href=""C:\Pupi.Pop""> questo </a>" & _
                "o anche <a href=""C:\Pepi.Pop""> quello </a>" & _
                "a piacere... e buon lavoro!"
            Ie.Document.Body.innerHTML = sDoc
            Ie.Document.Title = "Vista la " & URL & "???"
        End If
End Sub
Private Sub Ie_OnQuit()
    End
End Sub
Abbi come C:\Pippo.Htm un semplice file HTML, tipo:
<p> ciao! <p> prova <a href="pupi.pop"> questo </a>
oppure <a href="pepi.pop"> quello </a>
a scelta! <p> E buon lavoro...
OK, e` tutto.  Facendo partire il progetto VB, apparira`
naturalmente il suddetto Pippo.Htm.  Ma i clic sugli
hyperlink, che navigano verso inesistenti file ".Pop",
sono intercettati da Ie_BeforeNavigate2, la navigazione
e` cancellata, il nostro codice VB determina come meglio
crede il body ed il title da mostrare, e li piazza
dritti dritti nel documento-IE che si sta mostrando.
Ovviamente, qui lo stiamo facendo in modo-giocattolo,
ma nulla ti impedisce di fare qualsiasi operazione di
decrypting tu intendessi delegare alla .exe del Subject.
O piu` in generale, fartici la versione solo-client
di uno schema CGI o ASP o ...
Altrettanto, ovviamente ci sono vari piccoli dettagli
da migliorare, e questo specifico approccio non
facilita il bloccaggio della funzionalita` di "salva
la pagina" di IE (c'e` un po' da lavorare...).  Ma
mi pare che risponda sostanzialmente alla tua richiesta
iniziale, e non mi sembra che ci sia voluto molto:-).
Alex

 wrote in message 8jt9ih$pe1$1...@nslave1.tin.it...

Prego; e per premiare la tua cortesia nello scusarti
dell'errore, come vedi ho appena postato una brevissima
soluzione completa in Visual Basic.  In Visual C++ non
e` che ci voglia molto di piu`, naturalmente; se ti
serve, chiedi pure (su questo gruppo please).
Alex

serve, chiedi pure (su questo gruppo please).
"non e` che ci voglia molto di piu`, naturalmente;"
COME MI FA INCAZZARE !! ;))))
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------
#exclude <windows.h>


Rimangono comunque altre possibilità (giusto per elencare le prime che mi 
vengono in mente): 
- copia-incolla in un editor HTML o in outlook express (o attraverso un 
programma che provveda poi a trovare i link e richiedere le pagine 
successive...)
- realizzare un programmino che sfrutti l'activeX passandogli un oggetto 
"dom" ricavando da questo i dati (quindi anche l'activeX dovrebbe essere 
protetto in qualche modo e in grado di riconoscere se viene richiamato da 
IE o da un altro programma...).
- creare un oggetto che "simuli" il dom di IE (redirigendo le chiamate a 
quello originale dopo aver salvato i dati...) ed eseguire IE (o il 
programma wrapper)
- Trovare (con registry-monitor, file-monitor o simili) dove e come viene 
salvato il famoso numero di serie dell'HD e limitarsi ad adattarlo agli 
altri PC su cui sarà installato il programma... oppure (armandosi di santa 
pazienza e debugger) andare a modificare il programma in modo che faccia il 
test "al contrario" (funzioni solo sui PC dove il numero di serie non è 
valido).
Premetto (o meglio postmetto...) che non mi diletto a sproteggere programmi 
o database e le varie "strategie di attacco" di cui sopra possono essere 
ricavate da qualsiasi programmatore con qualche annetto di esperienza 
(sicuramente Alex potrebbe aggiungere almeno 20 sistemi alternativi, 
provarli e postare il codice in meno di un'ora :))
Credo che lo sforzo necessario per evitare copie non volute dei dati 
rischia di essere tempo sprecato. 
Queste risorse potrebbero essere dedicate a migliorare il supporto e i 
contenuti invitando gli utenti ad acquistare il prodotto "legale" (senza 
vincolarli a uno specifico browser e vincolare l'installazione del 
programma ad uno specifico PC).


 COME MI FA INCAZZARE !! ;))))
Beh, devo confessare che in questo caso non e` del
tutto vero; spesso lo e`, ma qui abbiamo un problema
specifico.
In generale, con #import, pur con tutti i suoi difetti
innegabili, scrivere clienti COM in Visual C++ e` ormai
divenuto quasi altrettanto semplice che in Visual Basic...
o, almeno, e` SPESSO cosi`.
Personalmente, preferisco ATL, che mi da` molto piu`
controllo su quello che sta succedendo (se e quando
programmo in C++, e` proprio per avere controllo cosi`
totale, dopo tutto); il "supporto nativo per COM" che
viene invocato da #import fa un po' troppe cose in modo
implicito ed automatico per i miei gusti (costruttori
non explicit, operatori di conversione, ...).  Pero`,
per programmi semplici, questo livello di automatismo
in effetti semplifica un pochetto la vita.
In questo specifico caso, la mancanza di "WithEvents"
nel "supporto nativo per COM" si fa purtroppo sentire.
Per lavorare in VC++, invece che in VB, un minimo di
fatica bisogna dunque effettivamente farla.
Comunque, ecco come schema e suggerimento un equivalente
della soluzione che ho gia` postato in Visual Basic;
anche qui, non e` arduo usare altri approcci per
"calcolare" l'HTML da mostrare sulla base della URL
fittizia a cui si sta "navigando" (e presumibilmente
si toglieranno i printf che qui ho lasciato per meglio
mostrare cosa sta succedendo).
Partendo da una console application di "hello world"
cosi` come il Wizard la genera...:
//
// esempio di pilotaggio di Internet Explorer 5 da
// console application VC++6
// Copyright (C) A. Martelli, 05/07/2000
//
#include "stdafx.h"
// nomi simbolici di alcuni eventi che ci interessano
#include <exdispid.h>
// le librerie dei tipi che ci servono
#pragma warning(disable: 4192)
#import <mshtml.tlb>
#import <shdocvw.dll>
// un typedef per comodita`
typedef SHDocVw::DWebBrowserEvents evbase_t;
// la funzione che gestira` i tentati
void BeforeNavigate(const char* url, VARIANT_BOOL* Cancel);
// la classe di gestione-eventi: dummizza tutto
// il dummizzabile, delega a BeforeNavigate l'unico
// lavoro concreto, termina l'applicazione quando
// arriva l'evento "quit" all'Internet Explorer
class myevents_t: public evbase_t {
public:
    // dummizza IUnknown
    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject)
{
        if( IsEqualGUID(riid, IID_IUnknown) ||
            IsEqualGUID(riid, IID_IDispatch) ||
            IsEqualGUID(riid, __uuidof(evbase_t)) ) {
                *ppvObject = (void*)this;
                return S_OK;
        }
        return E_NOINTERFACE;
    }
    ULONG STDMETHODCALLTYPE AddRef()  { return 2; }
    ULONG STDMETHODCALLTYPE Release() { return 1; }
    // dummizza IDispatch
    HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo)
        if(!pctinfo) return E_POINTER; *pctinfo = 0; return S_OK;
    }
    HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo
**ppTInfo) {
        return E_UNEXPECTED;
    }
    HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid, LPOLESTR
*rgszNames,
        UINT cNames, LCID lcid, DISPID *rgDispId) {
            return E_NOTIMPL;
    }
    HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid, LCID
lcid,
        WORD wFlags, DISPPARAMS __RPC_FAR *pDispParams, VARIANT __RPC_FAR
*pVarResult,
        EXCEPINFO __RPC_FAR *pExcepInfo, UINT __RPC_FAR *puArgErr) {
            switch(dispIdMember) {
            case DISPID_STATUSTEXTCHANGE:
                // evitiamo output eccessivo x eventi
                // troppo frequenti e non significativi
                break;
            case DISPID_QUIT:         // terminiamo il ciclo-di-messaggi
                printf("\nQuit\n");
                PostQuitMessage(0);
                break;
            case DISPID_BEFORENAVIGATE:    // l'unico che ci interessa
davvero
                printf("\nBeforeNavigate(%d args)\n",
                    pDispParams->cArgs);
                {
                    // estraiamo i parametri e deleghiamo alla funzione
                    variant_t vtCancel(pDispParams->rgvarg[0]);
                    variant_t vtUrl(pDispParams->rgvarg[5]);
                    bstr_t bUrl(vtUrl);
                    ::BeforeNavigate(bUrl, vtCancel.pboolVal);
                }
                break;
            default:        // eco puramente per debug/comprensione
                printf("Ev.%d ", dispIdMember);
            }
            return S_OK;
    }
};
// accesso al browser
SHDocVw::IWebBrowserAppPtr pIe;
//
// gestiamo i tentativi di "navigazione", che saranno di due
// tipi:
// verso "vero HTML", lo lasciamo fare (ad esempio ce n'e`
//     uno in partenza, e inoltre qui non disabilitiamo
//     la normale navigazione tramite la UI di IE) -- in
//     realta` lasciamo navigare verso qualsiasi URL che
//     non sia "fittizia", v. oltre, per generalita`
// verso "qualcosa.Pop", questo e` preso come "URL fittizia",
//     la navigazione in se` viene cancellata, e il nostro
//     codice provvede a generare il titolo ed il body sulla
//     base della stringa url-fittizia (qui lo facciamo in
//     modo-giocattolo, ma ovviamente potremmo delegare il
//     tutto ad arbitrarie .EXE esterne...) e a piazzarli
//     nel documento-corrente di IE
//
void BeforeNavigate(const char* url, VARIANT_BOOL* Cancel)
{
    printf("BeforeNavigate(%s, %s)\n",
        url, *Cancel?"true":"false");
    const char* dovePop = strstr(url, ".Pop");
    if(dovePop && dovePop[4]==0) {
        printf("Estensione .Pop, cancello\n");
        *Cancel = VARIANT_TRUE;
        MSHTML::IHTMLDocument2Ptr pDoc(pIe->GetDocument());
        bstr_t butil = "Eccoti la ";
        butil += url;
        pDoc->Puttitle(butil);
        butil = "Risultato della navigazione a ";
        butil += url;
        butil += "<p>Puoi comunque andare a "
                 "<a href=\"C:\\Primo.Pop\">primo</a> o "
                 "<a href=\"C:\\Secondo.Pop\">secondo</a> come preferisci!";
        pDoc->Getbody()->PutinnerHTML(butil);
    }
}
// un ciclo-di-messaggi, il piu` semplice possibile
void aspetta()
{
    MSG msg;
    while(GetMessage(&msg, 0, 0, 0)) {
        if(!TranslateMessage(&msg))
            DispatchMessage(&msg);
    }
}
// le operazioni COM da effettuare
void work()
{
    // facciamo partire un'istanza di Internet Explorer 5
    pIe = SHDocVw::IWebBrowserAppPtr(__uuidof(SHDocVw::InternetExplorer));
    // troviamo il connection-point per l'interfaccia d'eventi che gestiamo
    IConnectionPointContainerPtr pCpc(pIe);
    IConnectionPointPtr pCp;
    HRESULT hr = pCpc->FindConnectionPoint(__uuidof(evbase_t), &pCp);
    if(FAILED(hr)) _com_raise_error(hr);
    // connettiamo il nostro gestore-eventi al suddetto connection-point
    myevents_t myevents;
    DWORD cookie;
    hr = pCp->Advise(&myevents, &cookie);
    if(FAILED(hr)) _com_raise_error(hr);
    // iniziamo le operazioni: navighiamo ad un vero HTML (cio` e`
    // necessario inizialmente, cosi` che IE abbia un Document che
    // ha un Body, ecc) poi visualizziamo l'istanza di IE
    pIe->Navigate("C:\\Pippo.Htm");
    pIe->PutVisible(TRUE);
    // il resto delle operazioni sino alla fine va pilotato
    // dal ciclo-dei-messaggi (attraverso Eventi COM)
    aspetta();
    // sganciamo il nostro gestore di eventi e molliamo IE
    hr = pCp->Unadvise(cookie);
    if(FAILED(hr)) _com_raise_error(hr);
    pIe = 0;
}
//
// il main predispone il COM, chiama la funzione di lavoro
// in un try/catch per diagnosticare eventuali errori COM,
// e alla fine sgancia il COM.
//
int main( void )
{
    CoInitialize(0);
    try {
        work();
    } catch(_com_error& er) {
        printf("COM Error (%x): %s\n",
            er.Error(), er.ErrorMessage());
    }
    CoUninitialize();
    return 0;
}
Spero che sia tutto sufficientemente chiaro -- a chi gia`
conosce C++, e ha una vaga idea del supporto Visual C++
per COM, almeno; agli altri consiglio caldamente di basarsi
sulla versione Visual Basic che ho gia` postato!-)
Alex

 programma ad uno specifico PC).
Notiamo, tra l'altro, che "vincolare a uno specifico browser"
presenta enormi vantaggi, se appena appena e` possibile: senza
questi "vincoli", sei legato a quel microscopico sottoinsieme
(poverissimo!) dell'HTML che tutti i browser supportano, o a
mile salti mortali per scoprire quale sia il browser per vedere
quale esatta versione della pagine devi tornargli ("in locale",
il problema e` poi anche peggio!).
Per qualsiasi programma che possa commercialmente permetterselo,
io raccomando di istallare IE5 come parte dell'istallazione del
programma stesso, semplificandosi di conseguenza la vita e
usando (come minimo) tutti gli standard W3C sull'HTML dinamico,
lo scripting, e cosi` via, che IE5 supporta bene.  Se un domani
Mozilla (ad esempio) dovesse supportarli altrettanto bene, e
offrire un'interfaccia a programmi-di-pilotaggio che presenti
una potenza e flessibilita` analoghe a quelle che da anni offre
IE, non sara` difficile supportare anch'esso (ma io non terrei
il fiato aspettando che succeda).
Il vincolo su di un solo PC, necessario per l'approccio "dongle
di decodifica", e` in effetti una notevole scocciatura per
l'utente onesto, soprattutto oggi che si sta abituando ad
avere in rete (almeno intranet) anche ben altre applicazioni
(e sempre piu` nel futuro, che sia Microsoft .NET o che siano
altre tecnologie analoghe a spingere questo cambiamento).
Ad un certo punto bisognera` prevedere una "versione server"
ovvero "versione in Web" del prodotto, con un business model
drasticamente diverso, basato su abbonamento (e un simile
business model e` gia` molto sensato oggi, sia per il fornitore
sia per il cliente; noi siamo stati all'avanguardia nell'adozione
del concetto di "abbonamento", e funziona *veramente* meglio
del tradizionale "acquisto" del software, ormai possiamo dirlo
sulla base della nostra esperienza).  Ma l'enforcement della
licenza richiedera` probabilmente attivita` in rete (un qualche
tipo di handshake con un server centralizzato che sa chi ha
un valido abbonamento in corso, ecc ecc); questo a sua volta
*richiede* che l'accessibilita` della rete sia virtualmente
perenne e costante per i nodi che vogliono fruire del prodotto.
Una versione "node-locked" per PC isolati sara` dunque senza
dubbio necessaria per un LUNGO periodo di tempo, per questa
come per tante altre applicazioni, sino a quando il concetto
stesso di un PC che "in questo momento non vede la rete" non
arrivera` ad apparirci ridicolo e contraddittorio (e secondo
me ci vorranno molti anni per arrivare a quello stadio).
Alex

 wrote in message
8jtkhc$kq5$1...@nslave2.tin.it...


 poi a questi ritocchi.
L'approccio migliore e` probabilmente quello di non istanziare
l'intera applicazione IE, come ho fatto nell'esempio, ma solo
il controllo ActiveX che essa contiene, imbeddandolo nel tuo
form.  Cosi` la funzionalita` risulta *SERIAMENTE* ridotta!-)
Usa Project/Components.../Microsoft Internet Controls; questo
ti aggiunge alla tavolozza il controllo "WebBrowser", che puoi
piazzare sul tuo form come ogni altro.  Ecco un esempio con un
form-ettino che aggiunge due bottoncini 'back' e 'home', e
fa il resize dinamico del controllo quando viene resizato lui;
ma su queste robe di interfaccia utente in Visual Basic penso
ne capisca piu` tu di me, e comunque c'e` un gruppo apposta su
Visual Basic per domandare!-)
Option Explicit
Option Compare Text
Dim prevUrl As String
Dim lastUrl As String
Dim homeUrl As String
Private Sub cmdBack_Click()
    On Error Resume Next
    WebBrowser1.Navigate prevUrl
End Sub
Private Sub cmdHome_Click()
    On Error Resume Next
    WebBrowser1.Navigate homeUrl
End Sub
Private Sub Form_Load()
    homeUrl = "C:\Pippo.Htm"
    lastUrl = homeUrl
    cmdHome_Click
End Sub
Private Sub Form_Resize()
    cmdBack.Left = Me.Width - 720
    cmdHome.Left = Me.Width - 720
    WebBrowser1.Width = Me.Width - 850
    WebBrowser1.Height = Me.Height - 850
End Sub
Private Sub WebBrowser1_BeforeNavigate2(ByVal pDisp As Object, _
    URL As Variant, Flags As Variant, TargetFrameName As Variant, _
    PostData As Variant, Headers As Variant, Cancel As Boolean)
        prevUrl = lastUrl
        lastUrl = URL
        If Right(URL, 4) = ".pop" Then
            Cancel = True
            pDisp.Document.body.innerHtml = _
                "<p><b>Boo!</b> da <i>" & URL & "<i>!"
        End If
End Sub
Alex

 wrote in message
8jvecr$m4$1...@serv1.iunet.it...


 parte questo mi è *utilissimo*, dall'altra mi nasce un altro problema...
Si`, questa e` l'idea implicita nella architettura che ho
prototipato nei vari programmi che ho postato.


 string ed assegnarli alle rispettive proprietà di document???
L'unico modo che mi viene in mente per garantire che IE
parsi tutta la tua pagina, header inclusi, e` metterla
da qualche parte che sia accessibile via URL (ad esempio
su di un file temporaneo) e farci "navigare" su IE con i
soliti metodi.  Quando la navigazione e` completa (ricevi
un evento che ti informa di cio`), puoi cancellare il file
temporaneo e prelevare dal Document di IE tutte le proprieta`
che desideri.  Naturalmente immagino che vorrai fare questo
su di un altro oggetto IE (nascosto) e non sullo stesso che
usi per mostrare le cose all'utente (analogamente potresti
fare una "nuova finestra", pure nascosta, ecc ecc, ma non
mi pare che questo offra altri vantaggi).
Alex

 tratti di una semplice distrazione da parte mia.  .All(0),
E infatti lo era, e la causa era di pensare a "una proprieta`"
mentre bisogna usare "dei metodi"... mannaggia che figura!-)
Prova un po' questo, e sappici dire:
Private Sub Ie_BeforeNavigate2(ByVal pDisp As Object, URL As Variant, _
    Flags As Variant, TargetFrameName As Variant, PostData As Variant, _
    Headers As Variant, Cancel As Boolean)
        lblStatus.Caption = URL
        If Right(URL, 4) = ".Pop" Then
            Cancel = True
            Dim sDoc As String
            sDoc = _
                "<HTML><HEAD><TITLE>" & "Lamia" & URL & _
                "</TITLE><BODY>" & _
                "<p>Ciao, sono " & URL & "<p>" & _
                "<p>prova <a href=""C:\Pupi.Pop""> questo </a>" & _
                "o anche <a href=""C:\Pepi.Pop""> quello </a>" & _
                "a piacere... e buon lavoro!" & _
                "</BODY></HTML>"
            Dim otem As Object
            Set otem = Ie.Document.open("Finto.Html", _
                "Nome" & URL, , False)
            Call otem.write(sDoc)
            Call otem.Close
        End If
End Sub
Il metodo "open" dell'oggetto-documento (...i cui parametri non
sembra che facciano molto, a dire il vero...) torna un oggetto
(definito nelle doc come "uno stream", ma secondo me e` una
Window; comunque, non importa) a cui si puo` applicare il metodo
"write", per sovrascrivere l'intero HTML attualmente contenuto;
al momento del ".close", l'HTML viene parsato e "renderato" (che
brutto verbo, mamma mia).  In pratica le tre chiamate a open,
write, close, fanno quel che concettualmente dovrebbe fare la
scrittura della ipotetica proprieta` che pare non esista:-).
Alex

 > > non esiste una proprietà dell'oggetto document che permette di settare


 Boh, non riesco a capire perché...
Presumibilmente perche`, a differenza dell'esempio che avevo
proposto io, non hai fatto iniziare esplicitamente il browser
con una navigazione a "c:\pippo.html" bensi` hai lasciato che
si usasse il default (che presumibilmente e` about:blank nel
browser che tu stai usando).  Se a questo punto scegli poi
di usare delle URL relative, il loro completamento ad URL
assolute sara` naturalmente per giustapposizione-di-moniker,
come sempre su IE5.  Le regole di questa giustapposizione
non sono complicatissime, comunque producono proprio questi
due risultati osservati:
    about:blank e` un moniker senza item, e i fornitore
        di moniker non definisce un separatore, quindi un
        item (URL relativa) e` solo giustapposto
    c:\pippo.html e` un moniker di file, con item
        pippo.html e root c:, e il fornitore di
        moniker definisce il separatore \ -- quindi
        un itel (URL relativa) e` giustapposto alla
        root usando il separatore
Perche` non provi a iniziare con una navigazione ad un
singolo, esplicito, esistente file HTML?  L'effetto mi
sembra assai preferibile.
Alex