Newsgroup: it.comp.software.cad
Titolo: 1° question-> gestire file di risorse

le domande sono parecchie (non voglio bombardare il forum comunque)
1- esiste qualche tool visuale eventualmente che mi permetta di gestire le
risorse delle app. mdl ?
    io conosco visual c++ e c/c++ o letto un articolo (l'unico che gira in
rete per usare le mfc dialog-based con mdl ) ma non era molto.. chiaro
    eventuali chiarimenti ?
2-in un file di risorse esiste qualche comando tipo include ? in modo da
poter separare le varie parti in moduli più piccoli altrimenti con progetti
   di un certo livello diventa un macello.
3-ho trovato errore di codice duplicate negli esempi dei file di microstaion
confermate ? interi blocchi ripetuti più volte...
per adesso è questo ripeto avrei altre domande... ma mi fermo qui grazie
ciao.

 ha scritto nel messaggio
news:0h3Qc.71680$OR2.4...@news3.tin.it...


    di un certo livello diventa un macello.
se vuoi usare RDE fa tutto dall'editor visuale; puoi usare piu' files di
risorse, non e' necessario mettere tutto nello stesso file
se non l'hai gia' fatto scarica gli esempi dal sito della bentley
(specifiche per la tua versione di Microstation); un'ottima risorsa sono i
newsgroup di bentley, news://news,
viecon.com/bentley.microstation.v8.mdl
 (in
inglese, ci troverai anche vari miei messaggi)

 ha scritto nel messaggio
news:YR9Qc.97072$5D1.4...@news4.tin.it...


 tu usi .net ?
L'ho provato per un progetto ma ci sono delle complicazioni (documentate da
Microsoft) per le cosiddette mixed dll (che contengono anche codice nativo
oltre a codice managed, soluzione obbligata per una dlm); in pratica la dll
potrebbe bloccarsi se nella MdlMain utilizzi parti in managed code, ma forse
anche in altri casi. Il bug di .NET verra' risolto con la versione 2 del
framework
Anche il fatto di usare piu' linguaggi .NET (anche questa e' una scelta
obbligata perche' la parte di "aggancio" va fatta in c++.NET e usare c++ e'
una complicazione inutile nella maggior parte dei casi) da' problemi con
Visual Studio (io in pratica cercavo di ereditare in c# da una classe in
c++, tutto OK in esecuzione ma dava errore l'editor visuale di Visual
Studio)
Un altro problema sono i percorsi di ricerca delle dll aggiuntive (io ne ho
usate), di default le cerca nel path di ustation.exe e non nel percorso di
installazione della mia applicazione.
Nonostante tutte queste complicazioni sono comunque riuscito a mettere in
piedi la cosa ma non so fino a che punto e' affidabile (ho fatto il tutto a
scopo di ricerca mi interessa senz'altro scambiare qualche opinione), anche
perche' non mi risulta che esistano applicazioni commerciali con questa
architettura (anche se in futuro saranno senz'altro tutte cosi', Mozart
avra' un supporto nativo per .NET)

 > stupendo rde (azz risparmierò un bel pò ti tempo....)


 oppure del codice riutilizzabile nelle dll. (magari dll di risorse )
mdl e' diventata in pratica una libreria; realizzando una applicazione
completamente in VC ti serve solo una risorsa per l'aggancio dell'ma
(privo di codice) alla dll; a questo punto tra le proprieta' del
progetto setta il flag "use managed code", in compilazione ti
comparira' un warning sibilinno relativo al bug cui ti accennavo (io
ho fatto in modo di rimuovere chiamate a .NET dalla MdlMain e la parte
di inizializzazione relativa a .NET l'ho messa in una funzione
richiamata tramite keyin, cosi' dovrebbe essere affidabile)
per la parte di aggancio tra parte in C (dlm microstation standard) e
parte c++.net con windows forms c'e' un articolo su 
www.sumbera.net
che e' un buon punto di partenza; io sono andato avanto creandomi una
mia classe base BentleyForm che ha un comportamento standard
all'interno di Microstation (si tratta di ridefinire il comprtamento
sul minimize maximize e di aggiungerla alla lista di finestre di
Microstation, il tutto tramite funzioni mdl); per questa parte ho
usato c++.net da qui in poi c# ereditando appunto dalla classe base
cosi' definita

 ha scritto nel messaggio
news:cf9e644b.04080...@posting.google.com...


 le dlm sono un sorta di dll di microstation ?
scaricati gli esempi in mdl e l'articolo che spiega passo passo come
convertire da mdl a VC (sono dei passi quasi automatici); finito il tutto,
crei l'ma e la dll (che praticamente sostituisce l'mp ed a differenza di
questo non va linkato con l'ma)
ora setta il flag "use managed extension" ed usa il wizard per aggiungere
una form:
nella classe generata fa qualche modifica per farla "vivere" dentro
Microstation:
questa va piu' che bene (e' la classe base che uso in TileMaker e da cui
derivo le altre):
#pragma once
#include "stdafx.h"
#include "windows.h"
#undef MessageBox
#define winNT
#define NO_BOOLEAN_TYPE
#include "mssystem.fdf"
#include "msnativewindow.h"
#include "BentleyFormWrapper.h"
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
namespace BentleyForm
{
 /// <summary>
 /// Summary for BentleyForm
 ///
 /// WARNING: If you change the name of this class, you will need to change
the
 ///          'Resource File Name' property for the managed resource
compiler tool
 ///          associated with all .resx files this class depends on.
Otherwise,
 ///          the designers will not be able to interact properly with
localized
 ///          resources associated with this form.
 /// </summary>
 public __gc class BentleyForm : public System::Windows::Forms::Form
 {
 private:
  BentleyFormWrapper *wrapper;
 public:
  BentleyForm(void)
  {
   InitializeComponent();
  }
 protected:
  void Dispose(Boolean disposing)
  {
   if (disposing && components)
   {
    components->Dispose();
   }
   __super::Dispose(disposing);
  }
 private:
  /// <summary>
  /// Required designer variable.
  /// </summary>
  System::ComponentModel::Container* components;
  /// <summary>
  /// Required method for Designer support - do not modify
  /// the contents of this method with the code editor.
  /// </summary>
  void InitializeComponent(void)
  {
   //
   // BentleyForm
   //
   this->AutoScaleBaseSize = System::Drawing::Size(5, 13);
   this->ClientSize = System::Drawing::Size(292, 266);
   this->Name = S"BentleyForm";
   this->Text = S"BentleyForm";
   this->Load += new System::EventHandler(this, BentleyForm_Load);
            this->SizeChanged += new System::EventHandler(this,
BentleyForm_SizeChanged);
   this->Closed += new System::EventHandler(this, BentleyForm_Closed);
  }
 private: System::Void BentleyForm_Load(System::Object *  sender,
System::EventArgs *  e)
   {
   char titoloDialog __nogc[256];
            wrapper = new BentleyFormWrapper();
            // attenzione vado per titolo:
   // se cambio titolo devo cambiare anche qui
   getCharValue(titoloDialog, this->Text);
   HWND formWin = FindWindow(NULL,titoloDialog); // not perfect...
   //HWND formWin = this->Handle;
   mdlNativeWindow_initialize(titoloDialog); // init native window for MS
   mdlNativeWindow_createMSWindow (&wrapper->pWindow, formWin, FALSE, TRUE,
1);
   mdlNativeWindow_addToWindowList(wrapper->pWindow);    // add to window
list in MS
            mdlNativeWindow_setAsChild(wrapper->pWindow,0,FALSE); // set
parent to MS
            // set redirection for hooks ..still same way as in MFC
   // la funzione non deve essere overloaded(?) provare con final
            //wrapper->hHook = SetWindowsHookEx( WH_GETMESSAGE,
wrapper->GetMsgProc, NULL, GetCurrentThreadId());
   }
    private: System::Void BentleyForm_SizeChanged(System::Object *  sender,
System::EventArgs *  e)
             {
             if (this->WindowState  ==  FormWindowState::Minimized)
                 mdlNativeWindow_minimize(wrapper->pWindow);
             else if (this->WindowState  ==  FormWindowState::Maximized)
                 mdlNativeWindow_maximize(wrapper->pWindow);
             }
 private: System::Void getCharValue(char *c, System::String *s)
    {
    for (int i=0; i < s->Length; i++)
     c[i] = s->Chars[i];
    c[i] = 0;
    }
 private: System::Void BentleyForm_Closed(System::Object *  sender,
System::EventArgs *  e)
   {
   //MessageBox::Show(S"Finestra chiusa");
   mdlNativeWindow_removeFromWindowList(wrapper->pWindow);
            mdlNativeWindow_destroyMSWindow(wrapper->pWindow,FALSE);
            //UnhookWindowsHookEx(wrapper->hHook);
            delete wrapper;
   }
 };
}
(nota il wrapper che mi serve per utilizzare tipi di dati unmanged)
per aprire la form fatti una funzione del genere in C:
// Funzione da richiamare da .c
extern "C" void  loadForm(){
 // utilizza una classe statica dove conservo form...
 try
 {
  ManObj::form = new DBForms::TMaker_Article();
  ManObj::form->Show();
 }
 catch (Exception *ex)
 {
  MessageBox::Show(ex->Message);
 }
}
VC unmanaged e MFC te le sconsiglio visto che sono tecnologia obsoleta ormai
nota che alla fine avrai un'unica dll cosiddetta "mixed"

complicazione inutile)
ma alla fine mi sembra di capire che non conviene usare dll esterne siano
visual c++ o dont net ( che ho installato da poco) e piů
fare tutto dentro
microstation ?
bye.

 bye.
dipende da cosa si vuol fare; io ad esempio uso .NET per collegarmi e
mantenere un catalogo online di prodotti... il solo aprire un socket
in C (mdl) e' fonte di grosse complicazioni, la stessa cosa in .NET
(aprire un file XML, sincronizzare un file locale, scaricare dei
pattern da server per il render) e' banale
Microstation e' programmabile in molti modi, ogni linguaggio ha i suoi
pro e contro ed e' indicato per certe cose; se devi sviluppare un
comando per integrare microstation fai allo stesso modo in cui e'
stato sviluppato il 99% di Microstation e cioe' usa MDL, applicazioni
in rete jmdl fino ad msj c# da v8, vba per macro e piccole utility o
interfaccia a dll VB, etc. etc.

 interfaccia a dll VB, etc. etc.
Ma per quella parte fatta i c# intendi tramite una dll esterna ?
e hookando i messaggi ?  , lo stesso procedimento che userei se decido di
farla in visual c++ ?