Exemple #1
0
void do_sell( char_data* ch, char* argument )
{
  char_data*   keeper;
  thing_array*  array;
  obj_data*       obj;

  if( ( keeper = find_keeper( ch ) ) == NULL )
    return;

  if( is_set( &ch->in_room->room_flags, RFLAG_PET_SHOP ) ) {
    process_tell( keeper, ch, "We don't buy pets." );
    ch->reply = keeper;
    return;
    }

  if( *argument == '\0' ) {
    send( ch, "Sell what?\r\n" );
    return;
    }

  if( ( array = several_things( ch, argument, "sell", 
    &ch->contents ) ) == NULL ) 
    return;

  thing_array   subset  [ 5 ];
  thing_func*     func  [ 5 ]  = { cursed, stolen, uninterested,
                                   not_empty, sold };

  sort_objects( ch, *array, keeper, 5, subset, func );

  page_priv( ch, NULL, empty_string );
  page_priv( ch, &subset[1], "don't own" );
  page_priv( ch, &subset[2], "isn't interested in", keeper );
  page_priv( ch, &subset[0], "can't let go of" );
  page_priv( ch, &subset[3], NULL, NULL, "isn't empty", "aren't empty" );
  page_publ( ch, &subset[4], "sell", keeper, "to", "for" );

  for( int i = 0; i < subset[4]; i++ ) {
    obj = (obj_data*) subset[4][i];
    obj = (obj_data*) obj->From( obj->selected );

    set_bit( obj->extra_flags, OFLAG_IDENTIFIED );
    set_bit( obj->extra_flags, OFLAG_KNOWN_LIQUID );

    if( obj->pIndexData->item_type == ITEM_WAND
      || obj->pIndexData->item_type == ITEM_STAFF ) 
      obj->value[3] = obj->pIndexData->value[3];

    free_string( obj->label, MEM_OBJECT );
    obj->label = empty_string;

    obj->owner = NULL;
    add_coins( ch, obj->temp );
    obj->To( keeper );
    consolidate( obj );
    }

  delete array;
}
Exemple #2
0
void knapsack_solve(struct problem_t *p)
{
	assert(p->n > 0);
	
	print_objects(p);
	sort_objects(p);
	print_objects(p);
}
Exemple #3
0
void do_buy( char_data *ch, char *argument )
{
  char             buf  [ MAX_INPUT_LENGTH ];
  char_data*    keeper;
  char_data*       pet;
  obj_data*        obj;
  room_data*      room;
  thing_array*   array;

  if( ( keeper = find_keeper( ch ) ) == NULL )
    return;

  /* PET SHOP */

  if( is_set( &ch->in_room->room_flags, RFLAG_PET_SHOP ) ) {
    if( ch->species != NULL  ) {
      send( ch, "Monsters can't buy pets." );
      return;
      }

    if( ( room = get_room_index( ch->in_room->vnum+1 ) ) == NULL ) {
      send( ch, "The pet shop is still under construction.\r\n" );
      return;
      }

    thing_array list;

    for( int i = 0; i < room->contents; i++ ) 
      if( ( pet = character( room->contents[i] ) ) != NULL
        && buyable_pet( pet ) )
        list += pet;

    if( ( pet = one_character( ch, argument, "buy", &list ) ) == NULL )
      return;

    if( pet->shdata->level > ch->shdata->level ) {
      send( ch, "%s is too high a level for you.\r\n", pet );
      return;
      }

    if( pet->species->price == 0 ) {
      send( ch,
        "That pet is not for sale until a god sets a price for it.\r\n" );
      return;
      }

    if( is_set( &pet->species->act_flags, ACT_MOUNT ) ) {
      if( has_mount( ch ) )
        return;
      }
    else {
      if( number_of_pets( ch ) >= 2 ) {
        send( ch, "You already have two pets.\r\n" );
        return;
        }
      }

    sprintf( buf, "You hand %s", keeper->descr->name ); 
    if( !remove_coins( ch, pet->species->price, buf ) ) {
      if( ch->shdata->level < LEVEL_APPRENTICE ) {
        send( ch, "You can't afford it.\r\n" );
        return;
        }
      send( ch, "You don't have enough gold, but it doesn't seem to\
 matter.\r\n" );
      }

    pet->From( );
    pet->To( ch->array );

    set_bit( &pet->status, STAT_PET );
    add_follower( pet, ch );

    send( ch, "Enjoy your pet.\r\n" );
    fsend( ch, "%s bought %s as a pet.\r\n", ch, pet );

    if( pet->reset != NULL ) {
      pet->reset->count--;
      pet->reset = NULL;
      }
    return;
    }

  /* OBJECT SHOP */

  thing_array list;

  for( int i = 0; i < keeper->contents; i++ ) {
    obj = (obj_data*) keeper->contents[i];
    if( will_trade( keeper, obj ) )
      list += obj;
    }
    
  if( ( array = several_things( ch, argument, "buy", &list ) ) == NULL )
    return;

  thing_array   subset  [ 4 ];
  thing_func*     func  [ 4 ]  = { heavy, many, cantafford, buy };

  sort_objects( ch, *array, keeper, 4, subset, func );
  
  page_priv( ch, NULL, empty_string );
  page_priv( ch, &subset[0], "can't lift" );
  page_priv( ch, &subset[1], "can't handle" );
  page_priv( ch, &subset[2], "can't afford" );
  page_publ( ch, &subset[3], "buy", keeper, "from", "for" );

  delete array;
}
Exemple #4
0
//
//  function: MainWndHandler(HWND, unsigned, WORD, LONG)
//
//  purpose:	make initialisations (globals, Def-TTY settings)
//				create Toolbox Dialog
//
//			    process  Menu Selections
//					load/save Config
//					play/capture Archive 
//					open midi-device
//					change com settings
//					connect/disconnect to EEG-amp
//					load/save Config
//
//				scale and paint the channel-oscilloscope
//
//
//
LRESULT CALLBACK MainWndHandler(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	char sztemp[256];
    
	switch( message ) 
	{

	 case WM_CREATE:
		break;

	 case WM_ENABLE:
		 if ((wParam==TRUE) && (NB_OBJ != NULL)) 
		 {
			 NB_OBJ->update_channelinfo();
			 NB_OBJ=NULL;
		 }
		 break;

	 case WM_COMMAND:
			wmId    = LOWORD(wParam); 
			wmEvent = HIWORD(wParam); 
			// Menüauswahlen analysieren:
			switch( wmId ) 
			{

				case IDM_NEWCONFIG:
					stop_timer();
					TTY.read_pause=1;
					//BreakDownCommPort();
					CAPTFILE.do_read=0;
					close_captfile();

					if (ghWndAnimation!=NULL) SendMessage(ghWndAnimation,WM_CLOSE,0,0);
					ghWndAnimation=NULL;
					close_toolbox();

	 		   	    write_logfile("new config: deleting all objects.");
					while (GLOBAL.objects>0)
						free_object(0);

					deviceobject=NULL;
					GLOBAL.showdesign=TRUE;
					ShowWindow(ghWndDesign,TRUE);
				    SetWindowPos(ghWndDesign,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
					SetDlgItemText(ghWndStatusbox,IDC_DESIGN,"Hide Design"); 
					GLOBAL.hidestatus=FALSE;
					ShowWindow(ghWndStatusbox,TRUE);
				    SetWindowText(ghWndMain,"BrainBay");
					GLOBAL.configfile[0]=0;
					init_system_time();	PACKET.readstate=0;
					GLOBAL.session_length=0;
					SetDlgItemText(ghWndStatusbox,IDC_STATUS,"ready.");
					SetDlgItemInt(ghWndStatusbox,IDC_SAMPLINGRATE,PACKETSPERSECOND,0);
					SetDlgItemText(ghWndStatusbox,IDC_STATUS,"Configuration loaded");
					SetDlgItemText(ghWndStatusbox,IDC_TIME,"0.0");
					SetDlgItemText(ghWndStatusbox,IDC_JUMPPOS,"0.0");
					SetDlgItemText(ghWndStatusbox,IDC_SESSLEN,"0.0");
 					SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETPOS,TRUE,(LONG)0);
					SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELEND,TRUE,(LONG)0);
					SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELSTART,TRUE,(LONG)0);

 					InvalidateRect(ghWndDesign,NULL,TRUE);
					InvalidateRect(ghWndMain,NULL,TRUE);
					break;

				case IDM_SAVECONFIG:
					{ 
						char configfilename[MAX_PATH];
						int save_toolbox=GLOBAL.showtoolbox;

						close_toolbox();
						GLOBAL.showtoolbox=save_toolbox;
						strcpy(configfilename,GLOBAL.resourcepath); 
						if (GLOBAL.configfile[0]==0)
  						  strcat(configfilename,"CONFIGURATIONS\\*.con");
						else strcpy(configfilename,GLOBAL.configfile);
						if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_SAVE))
						{
						   if (!save_configfile(configfilename))  report_error("Could not save Config File");
						   else
						   {
							  char * d_name,new_name[80];
		  	 		   	      write_logfile("configruation saved.");

							  d_name=configfilename;
							  while (strstr(d_name,"\\")) d_name=strstr(d_name,"\\")+1;
							  strcpy(new_name,"BrainBay - ");strcat(new_name,d_name);
							  SetWindowText(ghWndMain,new_name);
						   }
						}
						if (GLOBAL.showtoolbox!=-1)
						{	
							actobject=objects[GLOBAL.showtoolbox];
							actobject->make_dialog();
						}
					}
					break;
				case IDM_LOADCONFIG:
					{ 
						char configfilename[MAX_PATH];
						close_toolbox();
						strcpy(configfilename,GLOBAL.resourcepath); 
						strcat(configfilename,"CONFIGURATIONS\\*.con");
						if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_LOAD))
						{
			 		   	    write_logfile("load config: free existing objects.");
							if (!load_configfile(configfilename)) report_error("Could not load Config File");
							else sort_objects();
						}
					
					}
					break;

				case IDM_ABOUT:
					close_toolbox();
				    DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)AboutDlgHandler);
					break;

				case IDM_HELP:
					{
						char tmpfile [250];
						close_toolbox();
						strcpy(tmpfile,GLOBAL.resourcepath);
						strcat(tmpfile,"brainbay_user_manual.pdf");
						ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
					}
					break;
				case IDM_VIEWLASTLOGFILE:
					{
						char tmpfile [250];
						close_toolbox();
						strcpy(tmpfile,GLOBAL.resourcepath);
						strcat(tmpfile,"bbay.log");
						ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
					}

					break;
				case IDM_EXIT:	
					DestroyWindow( hWnd );
				    break;
                
				case IDM_PLAY:	
						SendMessage(ghWndStatusbox,WM_COMMAND, IDC_RUNSESSION,0);
				    break;
				case IDM_STOP:			
						SendMessage(ghWndStatusbox,WM_COMMAND, IDC_STOPSESSION,0);
				    break;

				case IDM_NEUROSERVER:
						strcpy(sztemp,GLOBAL.resourcepath); 
						strcat(sztemp,"NETWORK\\nsd.exe");
						ShellExecute(hWnd, "open", sztemp, NULL, NULL, SW_SHOWNORMAL);
						break;
				case IDM_READEDF:
						{
							char edffilename[MAX_PATH];
							close_toolbox();
							strcpy(edffilename,GLOBAL.resourcepath); 
							strcat(edffilename,"ARCHIVES\\*.edf");
							if (open_file_dlg(hWnd,edffilename, FT_EDF, OPEN_LOAD))
							{
								strcpy(sztemp,GLOBAL.resourcepath); 
								strcat(sztemp,"NETWORK\\readedf.exe");
								ShellExecute(hWnd, NULL, sztemp, edffilename, NULL, SW_SHOWNORMAL);
							}
						}
						break;
				case IDM_EDITCOLORS:
					close_toolbox();
					display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITCOLORBOX, ghWndStatusbox, (DLGPROC)COLORDlgHandler));
					break;
				case IDM_EDITSCALES:
					close_toolbox();
					display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITSCALEBOX, ghWndStatusbox, (DLGPROC)SCALEDlgHandler));
					break;
				case IDM_SETTINGS:
                     if (ghWndSettings==NULL) ghWndSettings=CreateDialog(hInst, (LPCTSTR)IDD_SETTINGSBOX, ghWndStatusbox, (DLGPROC)SETTINGSDlgHandler);
					 else SetForegroundWindow(ghWndSettings);
					break;
				case IDM_DEVICESETTINGS:
					if (deviceobject) 
					{
						close_toolbox();
						actobject=deviceobject;
	//					GLOBAL.showtoolbox=find_object(devicebox);
						actobject->make_dialog(); 
						if (actobject->displayWnd) 
							SetWindowPos(actobject->displayWnd,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
					} else report ("No Amplifier Device present in the design");
					break;

				case IDM_INSERTMIDI: create_object(OB_MIDI); 
					break;
				case IDM_INSERTSPECTRUM: create_object(OB_FFT);
					break;	
				case IDM_INSERTTHRESHOLD: create_object(OB_THRESHOLD); 
					break;
				case IDM_INSERTFILTER:	create_object(OB_FILTER);						
					break;	
				case IDM_INSERTMAGNITUDE:create_object(OB_MAGNITUDE);						
					break;	
				case IDM_INSERTPARTICLE:create_object(OB_PARTICLE);						
					break;	
				case IDM_INSERTOSCI:create_object(OB_OSCI);						
					break;	
				case IDM_INSERTTRANSLATE:create_object(OB_TRANSLATE);						
					break;
				case IDM_INSERTSIGNAL:create_object(OB_SIGNAL);
					break;
				case IDM_INSERTAND:create_object(OB_AND);
					break;
				case IDM_INSERTOR:create_object(OB_OR);
					break;
				case IDM_INSERTNOT:create_object(OB_NOT);
					break;
				case IDM_INSERTWAV:
					if (!count_objects(OB_WAV)) create_object(OB_WAV);
					else report_error("Currently only one Sound player is supported.");
					break;
				case IDM_INSERTTCPRECEIVER:create_object(OB_TCP_RECEIVER);
					break;
				case IDM_INSERTDOKU:create_object(OB_DOKU);
					break;
                case IDM_INSERTEVAL:create_object(OB_EVAL);
					break;
				case IDM_INSERTAVI:create_object(OB_AVI);
					break;
				case IDM_INSERTAVERAGE:create_object(OB_AVERAGE);
					break;
				case IDM_INSERTCORR:create_object(OB_CORR);
					break;
				case IDM_INSERTEDFWRITER:create_object(OB_EDF_WRITER);
					break;
				case IDM_INSERTTCPSENDER:create_object(OB_TCP_SENDER);
					break;
				case IDM_INSERTEDFREADER:create_object(OB_EDF_READER);
					break;
				case IDM_INSERTCOMPARE:create_object(OB_COMPARE);
					break;
				case IDM_INSERTBALLGAME:create_object(OB_BALLGAME);
					break;
				case IDM_INSERTMIXER4:create_object(OB_MIXER4);
					break;
				case IDM_INSERTMOUSE:create_object(OB_MOUSE);
					break;
				case IDM_INSERTERPDETECT:create_object(OB_ERPDETECT);
					break;
				case IDM_INSERTCOM_WRITER:create_object(OB_COM_WRITER);
					break;
				case IDM_INSERTCAM:
					if (!count_objects(OB_CAM)) create_object(OB_CAM);
					break;
				case IDM_INSERTINTEGRATE:create_object(OB_INTEGRATE);
					break;
				case IDM_INSERTDEBOUNCE:create_object(OB_DEBOUNCE);
					break;
				case IDM_INSERTSAMPLE_HOLD:create_object(OB_SAMPLE_HOLD);
					break;
				case IDM_INSERTCONSTANT:create_object(OB_CONSTANT);
					break;
				case IDM_INSERTMATLAB:create_object(OB_MATLAB);
					break;
				case IDM_INSERTCOUNTER:create_object(OB_COUNTER);
					break;
				case IDM_INSERTSKINDIALOG:
					if (!count_objects(OB_SKINDIALOG)) create_object(OB_SKINDIALOG);
					break;
				case IDM_INSERTFILE_WRITER:create_object(OB_FILE_WRITER);
					break;
				case IDM_INSERTDEVIATION:create_object(OB_DEVIATION);
					break;
				case IDM_INSERTMCIPLAYER:create_object(OB_MCIPLAYER);
					break;
				case IDM_INSERTKEYSTRIKE:create_object(OB_KEYSTRIKE);
					break;
				case IDM_INSERTPEAKDETECT:create_object(OB_PEAKDETECT);
					break;
				case IDM_INSERTSPELLER:create_object(OB_SPELLER);
					break;
				case IDM_INSERTMARTINI:create_object(OB_MARTINI);
					break;
				case IDM_INSERTFILE_READER:create_object(OB_FILE_READER);
					break;
				case IDM_INSERTPORT_IO:create_object(OB_PORT_IO);
					break;
				case IDM_INSERTARRAY3600:create_object(OB_ARRAY3600);
					break;
				case IDM_INSERTCOMREADER:create_object(OB_COMREADER);
					break;
				case IDM_INSERTMIN:create_object(OB_MIN);
					break;
				case IDM_INSERTMAX:create_object(OB_MAX);
					break;
				case IDM_INSERTROUND:create_object(OB_ROUND);
					break;
				case IDM_INSERTDIFFERENTIATE:create_object(OB_DIFFERENTIATE);
					break;
				case IDM_INSERTDELAY:create_object(OB_DELAY);
					break;
				case IDM_INSERTLIMITER:create_object(OB_LIMITER);
					break;
				case IDM_INSERTFLOATVECTOR:
					create_object(OB_FLOATVECTOR);
					break;
				case IDM_INSERTVECTORFLOAT:
					create_object(OB_VECTORFLOAT);
					break;
				case IDM_INSERTDISPLAYVECTOR:
					create_object(OB_DISPLAYVECTOR);
					break;
				case IDM_INSERTVECTORBUFFER:
					create_object(OB_BUFFER);
					break;

				// here are th supported EED devices
				case IDM_INSERT_EEG_GENERIC8: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_RAW8BIT; create_object(OB_EEG);}
					break;
				case IDM_INSERT_EEG_GENERIC16: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_RAW; create_object(OB_EEG);}
					break;
				case IDM_INSERT_EEG_IBVA: 
					if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_IBVA; create_object(OB_EEG);}  
					break;
				case IDM_INSERT_EEG_NIA: 
					if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_NIA; create_object(OB_EEG);}  
					break;
				case IDM_INSERT_EEG_P21: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_MONOLITHEEG_P21; create_object(OB_EEG);} 
					break;
				case IDM_INSERT_EEG_OPENBCI8: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_OPENBCI8; create_object(OB_EEG);} 
					break;
				case IDM_INSERT_EEG_P2: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_MODEEG_P2; create_object(OB_EEG);}
					break;
				case IDM_INSERT_EEG_P3: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_MODEEG_P3; create_object(OB_EEG);}
					break;
				case IDM_INSERT_EEG_PENDANT: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_PENDANT3; create_object(OB_EEG);} 
					break;
				case IDM_INSERT_EEG_QDS: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_QDS; create_object(OB_EEG);}
					break;
				case IDM_INSERT_EEG_SBT4: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_SBT4; create_object(OB_EEG);} 
					break;
				case IDM_INSERT_EEG_SBT2: 
					if (!count_objects(OB_EEG))  { TTY.devicetype=DEV_SBT2; create_object(OB_EEG);} 
					break;
				// these devices need special care (seperate element)
				case IDM_INSERTOPTIMA:
					if ((!count_objects(OB_NEUROBIT)) && (!count_objects(OB_EEG))) create_object(OB_NEUROBIT);
					break;
				case IDM_INSERTEMOTIV:
					if ((!count_objects(OB_EMOTIV)) && (!count_objects(OB_EEG))) create_object(OB_EMOTIV);
					break;

				case IDM_COPY:
					if (actobject)
					{
						copy_object=actobject;
						if ((copy_object->type!=OB_EEG)&&(copy_object->type!=OB_WAV)&&(copy_object->type!=OB_CAM)
							&&(copy_object->type!=OB_SKINDIALOG)&&(copy_object->type!=OB_NEUROBIT))
						{
						    HANDLE hFile;
							char tmpfile[256];
							create_object(copy_object->type);

							strcpy(tmpfile,GLOBAL.resourcepath); 
							strcat(tmpfile,"tmp_copy.con");
							hFile = CreateFile(tmpfile, GENERIC_WRITE, 0, NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
							if(hFile != INVALID_HANDLE_VALUE)
							{
									copy_object->save(hFile);
									save_property(hFile,"end Object",P_END,NULL);
									CloseHandle(hFile);
							}
							hFile = CreateFile(tmpfile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
							if(hFile != INVALID_HANDLE_VALUE)
							{
									load_next_config_buffer(hFile);
									actobject->load(hFile);
									CloseHandle(hFile);
									DeleteFile(tmpfile);
							}
							actobject->xPos+=10; actobject->yPos+=10;
						}		
						close_toolbox();
					}
					break;
								
				default:
				   return DefWindowProc( hWnd, message, wParam, lParam );
			}
			break;

		case WM_ACTIVATE:
				{
/*				 char t[50];

				 static int cn=0;
				 cn++;
				 sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
				 SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
				 SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
				 UpdateWindow(ghWndStatusbox);
*/
			     if ((LOWORD(lParam)==WA_CLICKACTIVE) || (HIWORD(lParam)==WA_CLICKACTIVE))
				 	SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
				  SetFocus(ghWndMain);
			}
			break;


		case WM_ACTIVATEAPP: 

			{
/*				 char t[50];
				 static int cn=0;
				 cn++;
				 sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
				 SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
				 SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
				 UpdateWindow(ghWndStatusbox); */

//			     if ((LOWORD(lParam)==1828) || (LOWORD(lParam)==964))
				 	//SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
					SetWindowPos(ghWndMain,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
//				 return DefWindowProc( hWnd, message, wParam, lParam );
			}

			break;
		case WM_KEYDOWN:
		    if (lParam==KEY_DELETE )
			  SendMessage(ghWndDesign, message,wParam,lParam);
			 break;

		case WM_SIZE:
			 if (wParam== SIZE_MAXIMIZED) 
			 {
				 GLOBAL.main_maximized=lParam;
				 ShowWindow(ghWndStatusbox,TRUE);
				 GLOBAL.hidestatus=FALSE;
				 if (GLOBAL.session_length==0)
  				    SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)+15, 
			                   LOWORD(lParam)-8,HIWORD(lParam), 0);
				 else SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)-20, 
			                   LOWORD(lParam)-8,HIWORD(lParam), 0);
			 }
			 else if (wParam== SIZE_RESTORED) 
			 {
				WINDOWPLACEMENT  wndpl;
				GetWindowPlacement(ghWndMain, &wndpl);
				GLOBAL.top=wndpl.rcNormalPosition.top;
				GLOBAL.left=wndpl.rcNormalPosition.left;
				GLOBAL.right=wndpl.rcNormalPosition.right;
				GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
				GLOBAL.main_maximized=0;
				update_status_window();

			 }
			 else if (wParam== SIZE_MINIMIZED) 
			 {
				 ShowWindow(ghWndStatusbox,FALSE);
				 GLOBAL.hidestatus=TRUE;
			 }
			break;
    	case WM_MOVE:
			{
				WINDOWPLACEMENT  wndpl;
				GetWindowPlacement(ghWndMain, &wndpl);
				GLOBAL.top=wndpl.rcNormalPosition.top;
				GLOBAL.left=wndpl.rcNormalPosition.left;
				GLOBAL.right=wndpl.rcNormalPosition.right;
				GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
				update_status_window();
			}
			break;
		//case WM_PAINT:
		    //	break;
		case WM_DESTROY:
			actobject=0;
			GlobalCleanup();
			PostQuitMessage( 0 );
			break;
		case WM_INPUT:
			if ((TTY.CONNECTED) && (!GLOBAL.loading))
				ReadNIA( wParam, lParam);			// NIA Daten vorhanden: auslesen
				return(TRUE);
		default:
			return DefWindowProc( hWnd, message, wParam, lParam );
   }
   return 0;
}