Alphabetical Class Index  Class Hierarchy   File Members   Compound Members   File List  

HNetMessageRegistrar.h
00001 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
00002 //
00003 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
00004 // and considered a trade secret as defined under civil and criminal statutes.
00005 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
00006 // unauthorized use or misappropriation of its trade secrets.  Use of this information
00007 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
00008 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
00009 
00010 #ifndef _HNetMessageRegistrar_H
00011 #define _HNetMessageRegistrar_H
00012 
00013 #ifndef _HNET_MESSAGE_REGISTRAR
00014 #define _HNET_MESSAGE_REGISTRAR
00015 
00016 #ifdef H_PACK_8
00017 #pragma pack(push)
00018 #pragma pack(8)
00019 #endif
00020 
00021 #include "HBaseView.h"
00022 #include "HOpObjectAnnotate.h"
00023 #include "HOpCreateNurbs3D.h"
00024 #include "HMarkupManager.h"
00025 #include "vhash.h"
00026 #include <stdio.h>
00027 
00028 
00032 class MVOMessageHandler: public HNetMessageHandler {
00033 
00034 public:
00038     MVOMessageHandler(HBaseView * hbaseview){
00039         m_pHBaseView = hbaseview;
00040     };
00046     void ProcessMessage(
00047         const char * message_type,
00048         const char * data,
00049         unsigned int data_length) {;};
00050 
00051 protected:
00053     HBaseView * m_pHBaseView;
00054 };
00055 
00059 class HSetCameraMessageHandler: public MVOMessageHandler {
00060 public:
00064     HSetCameraMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00070     void ProcessMessage(
00071         const char * message_type,
00072         const char * data,
00073         unsigned int data_length) {
00074         m_pHBaseView->SetCameraFromMessage(data, data_length);
00075     };
00076 };
00077 
00081 class HSetRenderModeMessageHandler: public MVOMessageHandler {
00082 public:
00086     HSetRenderModeMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00092     void ProcessMessage(
00093         const char * message_type,
00094         const char * data,
00095         unsigned int data_length) {
00096         m_pHBaseView->SetRenderModeFromMessage(data, data_length);
00097     };
00098 };
00099 
00100 
00104 class HInsertHSFDataMessageHandler: public MVOMessageHandler {
00105 public:
00109     HInsertHSFDataMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00115     void ProcessMessage(
00116         const char * message_type,
00117         const char * data,
00118         unsigned int data_length) {
00119 
00120         m_pHBaseView->InsertHSFDataFromMessage(data, data_length);
00121     };
00122 };
00123 
00127 class HFlushBaseViewMessageHandler: public MVOMessageHandler {
00128 public:
00132     HFlushBaseViewMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00133 
00139     void ProcessMessage(
00140         const char * message_type,
00141         const char * data,
00142         unsigned int data_length) {
00143 
00144         m_pHBaseView->FlushFromMessage(data, data_length);
00145     };
00146 };
00147 
00148 
00152 class HDevNullMessageHandler: public HNetMessageHandler {
00153 public:
00159     void ProcessMessage(
00160         const char * message_type,
00161         const char * data,
00162         unsigned int data_length) {
00163 
00164     };
00165 };
00166 
00171 class HSelectMessageHandler: public MVOMessageHandler {
00172 public:
00176     HSelectMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00185     void ProcessMessage(
00186         const char * message_type,
00187         const char * data,
00188         unsigned int data_length) {
00189 
00190         if (strcmp(message_type,"H_DESELECT_ALL") == 0)
00191             m_pHBaseView->DeSelectAllFromMessage();
00192         else if (strcmp(message_type,"H_DELETE_SELECTION_LIST") == 0)
00193             m_pHBaseView->DeleteSelectionList();
00194         else
00195             m_pHBaseView->SelectFromMessage(data, data_length);
00196     };
00197 };
00198 
00199 
00203 class HDeleteByKeyMessageHandler: public MVOMessageHandler {
00204 public:
00208     HDeleteByKeyMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00209 
00215     void ProcessMessage(
00216         const char * message_type,
00217         const char * data,
00218         unsigned int data_length) {
00219 
00220         m_pHBaseView->DeleteByKeyFromMessage(data, data_length);
00221     };
00222 };
00223 
00224 
00228 class HSetWindowColorMessageHandler: public MVOMessageHandler {
00229 public:
00233     HSetWindowColorMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00239     void ProcessMessage(
00240         const char * message_type,
00241         const char * data,
00242         unsigned int data_length) {
00243 
00244         m_pHBaseView->SetWindowColorFromMessage(data, data_length);
00245     };
00246 };
00247 
00251 class HSetModellingMatrixMessageHandler: public MVOMessageHandler {
00252 public:
00256     HSetModellingMatrixMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00262     void ProcessMessage(
00263         const char * message_type,
00264         const char * data,
00265         unsigned int data_length) {
00266 
00267         m_pHBaseView->SetModellingMatrixFromMessage(data, data_length);
00268     };
00269 };
00270 
00275 class HMarkupMessageHandler: public MVOMessageHandler {
00276 public:
00280     HMarkupMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00289     void ProcessMessage(
00290         const char * message_type,
00291         const char * data,
00292         unsigned int data_length) {
00293 
00294         if (strcmp(message_type,"H_INSERT_MARKUP_LAYER_HSF_DATA") == 0)
00295             m_pHBaseView->GetMarkupManager()->InsertMarkupSegmentFromMessage(data, data_length);
00296         else if (strcmp(message_type,"H_SET_MARKUP_LAYER") == 0)
00297             m_pHBaseView->GetMarkupManager()->SetMarkupLayerFromMessage(data, data_length);
00298         else if (strcmp(message_type,"H_DISABLE_CURRENT_MARKUP_LAYER") == 0)
00299             m_pHBaseView->GetMarkupManager()->DisableCurrentMarkupLayerFromMessage(data, data_length);
00300     };
00301 };
00302 
00306 class HAnnotateObjectMessageHandler: public MVOMessageHandler {
00307 public:
00311     HAnnotateObjectMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00312     
00318     void ProcessMessage(
00319         const char * message_type,
00320         const char * data,
00321         unsigned int data_length) {
00322 
00323         HOpObjectAnnotate::AnnotateObjectFromMessage(m_pHBaseView, data, data_length);
00324     };
00325 };
00326 
00331 class HNurbsMessageHandler: public MVOMessageHandler {
00332 public:
00336     HNurbsMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00345     void ProcessMessage(
00346         const char * message_type,
00347         const char * data,
00348         unsigned int data_length) {
00349 
00350         if (strcmp(message_type,"H_INSERT_NURBS") == 0)
00351             HOpCreateNurbs3D::InsertNurbsFromMessage(data, data_length, m_pHBaseView);
00352         else if(strcmp(message_type,"H_FINISH_NURBS_EDITING") == 0)
00353             HOpCreateNurbs3D::FinishNurbsEditingFromMessage(data, data_length,m_pHBaseView);
00354         else if(strcmp(message_type,"H_MODIFY_CONTROL_POINT") == 0)
00355             HOpCreateNurbs3D::ModifyControlPointFromMessage(data, data_length, m_pHBaseView);
00356     };
00357 };
00358 
00362 class HSetHandednessMessageHandler: public MVOMessageHandler {
00363 public:
00367     HSetHandednessMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00373     void ProcessMessage(
00374         const char * message_type,
00375         const char * data,
00376         unsigned int data_length) {
00377         m_pHBaseView->SetHandednessFromMessage(data, data_length);
00378     };
00379 };
00380 
00384 class HSetFontSizeMessageHandler: public MVOMessageHandler {
00385 public:
00389     HSetFontSizeMessageHandler(HBaseView * hbaseview):MVOMessageHandler(hbaseview){;};
00395     void ProcessMessage(
00396         const char * message_type,
00397         const char * data,
00398         unsigned int data_length) {
00399         m_pHBaseView->SetFontSizeFromMessage(data, data_length);
00400     };
00401 };
00402 
00403 
00405 
00409 class HNetMessageRegistrar {
00410 
00411 public:
00412 
00419     HNetMessageRegistrar(
00420         HBaseView * new_hbaseview, 
00421         HNetClient * new_hnetclient=0) {
00422         
00423         hbaseview=new_hbaseview; 
00424         hnetclient=new_hnetclient;
00425 
00426         if(!hnetclient)
00427             message_handler_hash = new_vhash(1, malloc, free);
00428         else
00429             message_handler_hash = 0;
00430 
00431         default_message_handler=0;
00432 
00433     };
00434 
00439     virtual ~HNetMessageRegistrar() {
00440 
00441         UnSetHandlers();
00442 
00443         if(message_handler_hash) {
00444             delete_vhash(message_handler_hash);
00445             message_handler_hash=0;
00446         }
00447     }
00448 
00458     virtual void SetHandlers(){
00459 
00460         SetMessageHandler( new HSetCameraMessageHandler(hbaseview), "H_SET_CAMERA");
00461         SetMessageHandler( new HSetRenderModeMessageHandler(hbaseview), "H_SET_RENDERMODE");
00462         SetMessageHandler( new HInsertHSFDataMessageHandler(hbaseview), "H_INSERT_HSF_DATA");
00463         SetMessageHandler( new HFlushBaseViewMessageHandler(hbaseview), "H_FLUSH_BASE_VIEW");
00464         SetMessageHandler( new HDevNullMessageHandler(), "H_DEV_NULL_DATA");
00465         SetMessageHandler( new HSelectMessageHandler(hbaseview), "H_SELECT_ENTITY");
00466         SetMessageHandler( new HSelectMessageHandler(hbaseview), "H_DESELECT_ALL");
00467         SetMessageHandler( new HDeleteByKeyMessageHandler(hbaseview), "H_DELETE_BY_KEY");
00468         SetMessageHandler( new HSelectMessageHandler(hbaseview), "H_DELETE_SELECTION_LIST");
00469         SetMessageHandler( new HSetModellingMatrixMessageHandler(hbaseview), "H_SET_MODELLING_MATRIX");
00470         SetMessageHandler( new HAnnotateObjectMessageHandler(hbaseview), "H_ANNOTATE_OBJECT");
00471         SetMessageHandler( new HNurbsMessageHandler(hbaseview), "H_INSERT_NURBS");
00472         SetMessageHandler( new HNurbsMessageHandler(hbaseview), "H_MODIFY_CONTROL_POINT");
00473         SetMessageHandler( new HNurbsMessageHandler(hbaseview), "H_FINISH_NURBS_EDITING");
00474         SetMessageHandler( new HSetWindowColorMessageHandler(hbaseview), "H_SET_WINDOW_COLOR");
00475         SetMessageHandler( new HMarkupMessageHandler(hbaseview), "H_DISABLE_MARKUP_LAYER");
00476         SetMessageHandler( new HMarkupMessageHandler(hbaseview), "H_SET_MARKUP_LAYER");
00477         SetMessageHandler( new HMarkupMessageHandler(hbaseview), "H_INSERT_MARKUP_LAYER_HSF_DATA");
00478         SetMessageHandler( new HSetHandednessMessageHandler(hbaseview), "H_SET_HANDEDNESS");
00479         SetMessageHandler( new HSetFontSizeMessageHandler(hbaseview), "H_SET_FONT_SIZE");
00480 
00481     };
00482 
00488     virtual void UnSetHandlers(){
00489 
00490         if(hnetclient){ 
00491 
00492             hnetclient->EnumerateMessageHandlers(
00493                 net_unset_message_handler_helper, hnetclient);
00494 
00495         }else
00496         if(message_handler_hash){
00497             vhash_string_key_map_function(
00498                     message_handler_hash,
00499                     non_net_unset_message_handler_helper,
00500                     (void*)this);
00501         }
00502 
00503     };
00504 
00529     virtual HNetMessageHandler * SetMessageHandler(
00530             HNetMessageHandler * handler,
00531             const char * message_type)
00532     {
00533         HNetMessageHandler * old_handler=0;
00534         if(hnetclient)
00535             old_handler = hnetclient->SetMessageHandler(handler,message_type);
00536         else
00537         if(message_type){
00538             old_handler = (HNetMessageHandler *)vhash_remove_string_key(message_handler_hash, message_type);
00539             if(handler)
00540                 vhash_insert_string_key(message_handler_hash, message_type, (void*) handler);
00541         }else{
00542             if(default_message_handler) old_handler = default_message_handler;
00543             default_message_handler = handler;
00544         }
00545         return old_handler;
00546     }
00547 
00557     bool ReadSnapFile(const char * file_name) {
00558 
00559         FILE * file = fopen(file_name,"rb");
00560 
00561         if(file==NULL) return false;
00562         if(hnetclient) return false;
00563 
00564         unsigned long line_number = 0;
00565         unsigned long line_buffer_size = 1024;
00566         char * line_buffer;
00567         unsigned long n;
00568         unsigned long expected_n;
00569         int a_char;
00570         int read_again = 1;
00571 
00572         line_buffer = (char*) malloc(line_buffer_size);
00573         fseek(file,0,SEEK_SET);
00574 
00575 READ_A_LINE:
00576         n=0;
00577         expected_n=0;
00578         line_number++;
00579 
00580         while(1) {
00581             /*resize buffer as needed*/
00582             if(n == line_buffer_size) {
00583                 char * new_line_buffer;
00584                 new_line_buffer = (char*) malloc(line_buffer_size*2);
00585                 memcpy(new_line_buffer, line_buffer, line_buffer_size);
00586                 free(line_buffer);
00587                 line_buffer = new_line_buffer;
00588                 line_buffer_size = line_buffer_size*2;
00589             }
00590             a_char = fgetc(file);
00591             if(a_char == EOF) {
00592                 read_again=0;
00593                 break;
00594             }
00595             if(expected_n) {
00596                 line_buffer[n] = (char) a_char;
00597                 n++;
00598                 if(n==expected_n) {
00599                     /*have a whole line*/
00600                     ProcessMessage(line_buffer, n);
00601                     break;
00602                 }
00603             }else{
00604                 if(a_char == 0x0D || a_char == 0x0A) {
00605                     if(n == 0) continue;
00606                     /*this is a error in the file*/
00607                     read_again=0;
00608                     break;
00609                 }
00610                 if (a_char == ' ') {
00611                     line_buffer[n] = '\0';
00612                     sscanf(line_buffer, "%ld", &expected_n);
00613                     n=0;
00614                 }else{
00615                     line_buffer[n] = (char) a_char;
00616                     n++;
00617                 }
00618             }
00619         }
00620         if(read_again)
00621             goto READ_A_LINE;
00622         free(line_buffer);
00623         return true;
00624     };
00625 
00626 
00627 protected:
00628 
00636     virtual void ProcessMessage(
00637             const char * message,
00638             unsigned long message_length) {
00639 
00640             if(hnetclient) return;
00641 
00642             char * message_type = (char*) malloc(message_length);
00643             unsigned long n = 0;
00644 
00645             while(n < message_length && message[n] != ' ') {
00646                 message_type[n] = message[n];
00647                 n++;
00648             }
00649             message_type[n] = '\0';
00650             n++;
00651             HNetMessageHandler * message_handler =
00652                 (HNetMessageHandler *) vhash_lookup_string_key(message_handler_hash, message_type);
00653 
00654             if(!message_handler)
00655                 message_handler = default_message_handler;
00656             if(message_handler) 
00657                 message_handler->ProcessMessage(message_type, &message[n], message_length-n);
00658             free(message_type);
00659     }
00660 
00662     HBaseView * hbaseview; 
00664     HNetClient * hnetclient;
00665 
00666 private:
00667     struct vhash_s * message_handler_hash;
00668     HNetMessageHandler * default_message_handler;
00669 
00670     static void net_unset_message_handler_helper(
00671         void * handler,
00672         const char * message,
00673         void * user_data){
00674 
00675         ((HNetClient*)user_data)->SetMessageHandler(0,message);
00676         delete (HNetMessageHandler*)handler;
00677     };
00678 
00679     static void non_net_unset_message_handler_helper(
00680             void * handler,
00681             const char * message,
00682             void * user_data){
00683 
00684         HNetMessageRegistrar * self = (HNetMessageRegistrar *) user_data;
00685         self->SetMessageHandler(0,message);
00686         delete (HNetMessageHandler*)handler;
00687     };
00688 
00689 };
00690 
00691 
00692 #ifdef H_PACK_8
00693 #pragma pack(pop)
00694 #endif
00695 
00696 #endif
00697 #endif
00698 
00699 
00700