Hi, how can I tell if a VB application/DLL is currently only being run in
the development environment or stand-alone?

Richard

In VB go to your Project properties and click on the Make tab in the box
labeled "Command Line Arguments" type anything you like, for example put
"DEBUG" in there. Then in your code use something like this.

If Command = "DEBUG" then.....

Hope this helps!
Kurt

Another way is....
'==========
Option Explicit

Private Sub Form_Load()
   Show
   Print DesignMode
End Sub

Public Function DesignMode() As Boolean 'Place this function in a bas module or wherever.
   On Error Resume Next
   Debug.Print 1 / 0
   DesignMode = (Err.Number <> 0)
End Function
'==========

DesignMode will be True for the IDE and False for the EXE (since VB doesn't include Debug.Print in a compiled program)

    On Error Resume Next
    Debug.Print 1 \ 0
    If Err Then 'in IDE
        Err.Clear
        mnuTest.Visible = True
    Else 'not in IDE
        mnuTest.Visible = False
    End If

    On Error Resume Next
    Debug.Print 1/0
    bWeAreInTheIDE = (Err.Number <> 0)

Or a more complex function that avoids errors:

Public Function IsCompiled() As Boolean

    Static s_iState     As Integer
    Static s_bCompiled  As Boolean

    If s_iState = 0 Then
    ' first time we've called this function
        s_bCompiled = True
        s_iState = 1
        ' call IsCompiled() recursively, ONLY if run from the IDE...
        Debug.Assert Not IsCompiled()
        s_iState = 2
    ElseIf s_iState = 1 Then
    ' only get to here if called recursively, in which case we are NOT
compiled
        s_bCompiled = False
    End If

    IsCompiled = s_bCompiled

End Function

Both use the fact that methods of the Debug object are only executed in the
IDE, and not in a compiled EXE.

--
RobSmith

:
: Hi, how can I tell if a VB application/DLL is currently only being run in
: the development environment or stand-alone?
:
: Richard
:
:
:

here goes...(BTW this is 32 bit only code, ie vb5 and vb6)

Add it to a new module, and call it like so
if DevelopmentEnvironment(myForm.hWnd) then
        'working in IDE
else
        'running standalone
endif

===cut===
Option Explicit

Declare Function apiGetModuleFileName Lib "kernel32" Alias _
         "GetModuleFileNameA" (ByVal hModule As Long, ByVal _
         lpFileName As String, ByVal nSize As Long) As Long

Declare Function apiGetWindowWord Lib "user32" Alias _
         "GetWindowWord" (ByVal hwnd As Long, ByVal nIndex As _
         Long) As Integer

Global Const GWW_HINSTANCE = (-6)

Function DevelopmentEnvironment(my_hwnd As Long) As Boolean

    Dim ModuleName As String
    Dim FileName As String
    Dim hInst, ret As Integer

    ModuleName = String$(128, Chr$(0))
    ' Get the hInstance application:
    hInst = apiGetWindowWord(my_hwnd, GWW_HINSTANCE)
    ' Get the ModuleFileName:
    ' Enter the following two lines as one, single line:
    ModuleName = Left$(ModuleName, apiGetModuleFileName(hInst, ModuleName,
Len(ModuleName)))
    If (Len(ModuleName)) > 0 Then
        ' Get the "." in the file name. Then go back three characters.
        ' FileName should = \VB.EXE, so check for the backslash (\)
        ' because FileName could be GVB.EXE, which isn't the
        ' VB executable name:
        FileName = Mid$(ModuleName, InStr(ModuleName, ".") - 4)
        If FileName = "\VB6.EXE" Or FileName = "\VB5.EXE" Then
            DevelopmentEnvironment = True
        Else
            DevelopmentEnvironment = False
        End If
    End If

End Function

===cut===

--
 ----------------------------------------------------------------------------
| Jeff Goslin - MCSD,MCP | "Oh Bentson, you are so mercifully free from the  |

 ----------------------------------------------------------------------------
|   how come everyone elses religion is a cult but your cult is a religion   |
 ----------------------------------------------------------------------------
|      XGenetic, the ActiveX Artificial Intelligence Genetic Algorithm       |
|           http://www.winsite.com/info/pc/win95/demo/xgen-sw.zip/           |
 ----------------------------------------------------------------------------

Private Function TestVB(ByRef TestVar As Boolean) As Boolean
    TestVB = True
    TestVar = True
End Function

Public Function IsVBIDE() As Boolean
    Dim Test As Boolean        'Will be initialised to False
    Debug.Assert TestVB(Test)        'Since TestVB always returns True,
                                                      'Assert will not fail
    IsVBIDE = Test
End Function

The code works because VB only evaluates Assert statements when in the IDE.
Thus the Test variable will only be set to True if you are in the IDE. I
think you'll find this is the neatest way of achieving the desired result,
unless you do like using error traps. Also, this is not version dependent -
it will work in any version of VB after 5 (the Debug.Assert method was added
to the language in Version 5)

David Allsopp
Dave Software Enterprises

Private Sub Command1_Click()

    Dim lpClassName As String * 255
    Dim strClassName As String

    'At runtime VB class names have the prefix "ThunderRT," for example:
ThunderCheckBox becomes ThunderRTCheckBox at runtime.
    GetClassName Me.hwnd, lpClassName, 256
    strClassName = Left(lpClassName, InStr(lpClassName, Chr(0)) - 1)
    'In run time, it will contain the string "RT":
    If InStr(1, strClassName, "ThunderRT", vbTextCompare) > 0 Then
        MsgBox "Run Time"
    Else
        MsgBox "Design Time"
    End If
End Sub

Thank you to all who took the time to reply, your suggestions were varied
and I will give each one a try to see which one works best for me, I think
Jeff Goslin was the closest to what I was looking for, I need to be able to
disable a DLL when running stand-alone, and only allow it to run in the IDE
for demonstration purposes

Thanks again to everyone ;o)

Richard

--
...

Just a minor clarification: not all methods of the Debug object are
totally discarded during compilation.  If you change your code above to
use "Debug.Print Not IsCompiled()" then the routine fails when
compiled.  This is because although the Debug.Print is ignored, any
function calls in the line are still done.  Apparently this is not true
for Debug.Assert since that does work.

--
Please reply via the newsgroup only

Sent via Deja.com http://www.deja.com/
Before you buy.

Check out Karl Peterson's "Ask the VB Pro" column from the June '99 VBPJ for
a way to do this. It has the advantages of Jeff's suggestion, but is simpler
and requires no passed parameters.

Best,

Peter Young

- Jim

Sent via Deja.com http://www.deja.com/
Before you buy.

My apologies to assembly language purists out there who may note syntactical
errors in my explanation - I've only just started in assembly language!!

David Allsopp
Dave Software Enterprises

Debug.Print is designed for where you are actually evaluating something and
might want to see the results at debugging time.

Debug.Assert is Microsofts notion of an assertion language in VB. Assertion
languages (for example Eiffel) allow to specify Preconditions and
Postconditions as well as Invariant clauses on classes and routines. Such
assertions are only tests and so would not need to be evaluated at runtime.
The method used here takes advantage of this - really, the Not IsCompiled()
function should be evaluated at runtime because it's not a pure function,
but let's not get into a discussion of state machines!!!!!

David Allsopp